• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 dnl ***********************************************
2 dnl * Please run autoreconf to test your changes! *
3 dnl ***********************************************
4 
5 # Set VERSION so we only need to edit in one place (i.e., here)
6 m4_define(PYTHON_VERSION, 3.7)
7 
8 AC_PREREQ(2.65)
9 
10 AC_INIT(python, PYTHON_VERSION, https://bugs.python.org/)
11 
12 AC_CONFIG_MACRO_DIR(m4)
13 
14 AC_SUBST(BASECPPFLAGS)
15 if test "$srcdir" != . -a "$srcdir" != "$(pwd)"; then
16     # If we're building out-of-tree, we need to make sure the following
17     # resources get picked up before their $srcdir counterparts.
18     #   Objects/ -> typeslots.inc
19     #   Include/ -> Python-ast.h, graminit.h
20     #   Python/  -> importlib.h
21     # (A side effect of this is that these resources will automatically be
22     #  regenerated when building out-of-tree, regardless of whether or not
23     #  the $srcdir counterpart is up-to-date.  This is an acceptable trade
24     #  off.)
25     BASECPPFLAGS="-IObjects -IInclude -IPython"
26 else
27     BASECPPFLAGS=""
28 fi
29 
30 AC_SUBST(GITVERSION)
31 AC_SUBST(GITTAG)
32 AC_SUBST(GITBRANCH)
33 
34 if test -e $srcdir/.git
35 then
36 AC_CHECK_PROG(HAS_GIT, git, found, not-found)
37 else
38 HAS_GIT=no-repository
39 fi
40 if test $HAS_GIT = found
41 then
42     GITVERSION="git --git-dir \$(srcdir)/.git rev-parse --short HEAD"
43     GITTAG="git --git-dir \$(srcdir)/.git describe --all --always --dirty"
44     GITBRANCH="git --git-dir \$(srcdir)/.git name-rev --name-only HEAD"
45 else
46     GITVERSION=""
47     GITTAG=""
48     GITBRANCH=""
49 fi
50 
51 AC_CONFIG_SRCDIR([Include/object.h])
52 AC_CONFIG_HEADER(pyconfig.h)
53 
54 AC_CANONICAL_HOST
55 AC_SUBST(build)
56 AC_SUBST(host)
57 
58 # pybuilddir.txt will be created by --generate-posix-vars in the Makefile
59 rm -f pybuilddir.txt
60 
61 AC_CHECK_PROGS(PYTHON_FOR_REGEN, python$PACKAGE_VERSION python3 python, python3)
62 AC_SUBST(PYTHON_FOR_REGEN)
63 
64 if test "$cross_compiling" = yes; then
65     AC_MSG_CHECKING([for python interpreter for cross build])
66     if test -z "$PYTHON_FOR_BUILD"; then
67         for interp in python$PACKAGE_VERSION python3 python; do
68 	    which $interp >/dev/null 2>&1 || continue
69 	    if $interp -c "import sys;sys.exit(not '.'.join(str(n) for n in sys.version_info@<:@:2@:>@) == '$PACKAGE_VERSION')"; then
70 	        break
71 	    fi
72             interp=
73 	done
74         if test x$interp = x; then
75 	    AC_MSG_ERROR([python$PACKAGE_VERSION interpreter not found])
76 	fi
77         AC_MSG_RESULT($interp)
78 	PYTHON_FOR_BUILD='_PYTHON_PROJECT_BASE=$(abs_builddir) _PYTHON_HOST_PLATFORM=$(_PYTHON_HOST_PLATFORM) PYTHONPATH=$(shell test -f pybuilddir.txt && echo $(abs_builddir)/`cat pybuilddir.txt`:)$(srcdir)/Lib _PYTHON_SYSCONFIGDATA_NAME=_sysconfigdata_$(ABIFLAGS)_$(MACHDEP)_$(MULTIARCH) '$interp
79     fi
80 elif test "$cross_compiling" = maybe; then
81     AC_MSG_ERROR([Cross compiling required --host=HOST-TUPLE and --build=ARCH])
82 else
83     PYTHON_FOR_BUILD='./$(BUILDPYTHON) -E'
84 fi
85 AC_SUBST(PYTHON_FOR_BUILD)
86 
87 dnl Ensure that if prefix is specified, it does not end in a slash. If
88 dnl it does, we get path names containing '//' which is both ugly and
89 dnl can cause trouble.
90 
91 dnl Last slash shouldn't be stripped if prefix=/
92 if test "$prefix" != "/"; then
93     prefix=`echo "$prefix" | sed -e 's/\/$//g'`
94 fi
95 
96 dnl This is for stuff that absolutely must end up in pyconfig.h.
97 dnl Please use pyport.h instead, if possible.
98 AH_TOP([
99 #ifndef Py_PYCONFIG_H
100 #define Py_PYCONFIG_H
101 ])
102 AH_BOTTOM([
103 /* Define the macros needed if on a UnixWare 7.x system. */
104 #if defined(__USLC__) && defined(__SCO_VERSION__)
105 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
106 #endif
107 
108 #endif /*Py_PYCONFIG_H*/
109 ])
110 
111 # We don't use PACKAGE_ variables, and they cause conflicts
112 # with other autoconf-based packages that include Python.h
113 grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
114 rm confdefs.h
115 mv confdefs.h.new confdefs.h
116 
117 AC_SUBST(VERSION)
118 VERSION=PYTHON_VERSION
119 
120 # Version number of Python's own shared library file.
121 AC_SUBST(SOVERSION)
122 SOVERSION=1.0
123 
124 # The later defininition of _XOPEN_SOURCE disables certain features
125 # on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
126 AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])
127 
128 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
129 # certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
130 # them.
131 AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])
132 
133 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
134 # certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
135 # them.
136 AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])
137 
138 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
139 # certain features on Mac OS X, so we need _DARWIN_C_SOURCE to re-enable
140 # them.
141 AC_DEFINE(_DARWIN_C_SOURCE, 1, [Define on Darwin to activate all library features])
142 
143 
144 define_xopen_source=yes
145 
146 # Arguments passed to configure.
147 AC_SUBST(CONFIG_ARGS)
148 CONFIG_ARGS="$ac_configure_args"
149 
150 AC_MSG_CHECKING([for --enable-universalsdk])
151 AC_ARG_ENABLE(universalsdk,
152 	AS_HELP_STRING([--enable-universalsdk@<:@=SDKDIR@:>@], [Build fat binary against Mac OS X SDK]),
153 [
154 	case $enableval in
155 	yes)
156 		# Locate the best usable SDK, see Mac/README for more
157 		# information
158 		enableval="`/usr/bin/xcodebuild -version -sdk macosx Path 2>/dev/null`"
159 		if ! ( echo $enableval | grep -E '\.sdk' 1>/dev/null )
160 		then
161 			enableval=/Developer/SDKs/MacOSX10.4u.sdk
162 			if test ! -d "${enableval}"
163 			then
164 				enableval=/
165 			fi
166 		fi
167 		;;
168 	esac
169 	case $enableval in
170 	no)
171 		UNIVERSALSDK=
172 		enable_universalsdk=
173 		;;
174 	*)
175 		UNIVERSALSDK=$enableval
176 		if test ! -d "${UNIVERSALSDK}"
177 		then
178 			AC_MSG_ERROR([--enable-universalsdk specifies non-existing SDK: ${UNIVERSALSDK}])
179 		fi
180 		;;
181 	esac
182 
183 ],[
184    	UNIVERSALSDK=
185 	enable_universalsdk=
186 ])
187 if test -n "${UNIVERSALSDK}"
188 then
189 	AC_MSG_RESULT(${UNIVERSALSDK})
190 else
191 	AC_MSG_RESULT(no)
192 fi
193 AC_SUBST(UNIVERSALSDK)
194 
195 AC_SUBST(ARCH_RUN_32BIT)
196 ARCH_RUN_32BIT=""
197 
198 # For backward compatibility reasons we prefer to select '32-bit' if available,
199 # otherwise use 'intel'
200 UNIVERSAL_ARCHS="32-bit"
201 if test "`uname -s`" = "Darwin"
202 then
203 	if test -n "${UNIVERSALSDK}"
204 	then
205 		if test -z "`/usr/bin/file -L "${UNIVERSALSDK}/usr/lib/libSystem.dylib" | grep ppc`"
206 		then
207 			UNIVERSAL_ARCHS="intel"
208 		fi
209 	fi
210 fi
211 
212 AC_SUBST(LIPO_32BIT_FLAGS)
213 AC_MSG_CHECKING(for --with-universal-archs)
214 AC_ARG_WITH(universal-archs,
215     AS_HELP_STRING([--with-universal-archs=ARCH], [select architectures for universal build ("32-bit", "64-bit", "3-way", "intel", "intel-32", "intel-64", or "all")]),
216 [
217 	UNIVERSAL_ARCHS="$withval"
218 ],
219 [])
220 if test -n "${UNIVERSALSDK}"
221 then
222 	AC_MSG_RESULT(${UNIVERSAL_ARCHS})
223 else
224 	AC_MSG_RESULT(no)
225 fi
226 
227 AC_ARG_WITH(framework-name,
228               AS_HELP_STRING([--with-framework-name=FRAMEWORK],
229                              [specify an alternate name of the framework built with --enable-framework]),
230 [
231     PYTHONFRAMEWORK=${withval}
232     PYTHONFRAMEWORKDIR=${withval}.framework
233     PYTHONFRAMEWORKIDENTIFIER=org.python.`echo $withval | tr '[A-Z]' '[a-z]'`
234     ],[
235     PYTHONFRAMEWORK=Python
236     PYTHONFRAMEWORKDIR=Python.framework
237     PYTHONFRAMEWORKIDENTIFIER=org.python.python
238 ])
239 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
240 AC_ARG_ENABLE(framework,
241               AS_HELP_STRING([--enable-framework@<:@=INSTALLDIR@:>@], [Build (MacOSX|Darwin) framework]),
242 [
243 	case $enableval in
244 	yes)
245 		enableval=/Library/Frameworks
246 	esac
247 	case $enableval in
248 	no)
249 		PYTHONFRAMEWORK=
250 		PYTHONFRAMEWORKDIR=no-framework
251 		PYTHONFRAMEWORKPREFIX=
252 		PYTHONFRAMEWORKINSTALLDIR=
253 		FRAMEWORKINSTALLFIRST=
254 		FRAMEWORKINSTALLLAST=
255 		FRAMEWORKALTINSTALLFIRST=
256 		FRAMEWORKALTINSTALLLAST=
257 		FRAMEWORKPYTHONW=
258 		if test "x${prefix}" = "xNONE"; then
259 			FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
260 		else
261 			FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
262 		fi
263 		enable_framework=
264 		;;
265 	*)
266 		PYTHONFRAMEWORKPREFIX="${enableval}"
267 		PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
268 		FRAMEWORKINSTALLFIRST="frameworkinstallstructure"
269 		FRAMEWORKALTINSTALLFIRST="frameworkinstallstructure "
270 		FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools"
271 		FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkaltinstallunixtools"
272 		FRAMEWORKPYTHONW="frameworkpythonw"
273 		FRAMEWORKINSTALLAPPSPREFIX="/Applications"
274 
275 		if test "x${prefix}" = "xNONE" ; then
276 			FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
277 
278 		else
279 			FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
280 		fi
281 
282 		case "${enableval}" in
283 		/System*)
284 			FRAMEWORKINSTALLAPPSPREFIX="/Applications"
285 			if test "${prefix}" = "NONE" ; then
286 				# See below
287 				FRAMEWORKUNIXTOOLSPREFIX="/usr"
288 			fi
289 			;;
290 
291 		/Library*)
292 			FRAMEWORKINSTALLAPPSPREFIX="/Applications"
293 			;;
294 
295 		*/Library/Frameworks)
296 			MDIR="`dirname "${enableval}"`"
297 			MDIR="`dirname "${MDIR}"`"
298 			FRAMEWORKINSTALLAPPSPREFIX="${MDIR}/Applications"
299 
300 			if test "${prefix}" = "NONE"; then
301 				# User hasn't specified the
302 				# --prefix option, but wants to install
303 				# the framework in a non-default location,
304 				# ensure that the compatibility links get
305 				# installed relative to that prefix as well
306 				# instead of in /usr/local.
307 				FRAMEWORKUNIXTOOLSPREFIX="${MDIR}"
308 			fi
309 			;;
310 
311 		*)
312 			FRAMEWORKINSTALLAPPSPREFIX="/Applications"
313 			;;
314 		esac
315 
316 		prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
317 
318 		# Add files for Mac specific code to the list of output
319 		# files:
320 		AC_CONFIG_FILES(Mac/Makefile)
321 		AC_CONFIG_FILES(Mac/PythonLauncher/Makefile)
322 		AC_CONFIG_FILES(Mac/Resources/framework/Info.plist)
323 		AC_CONFIG_FILES(Mac/Resources/app/Info.plist)
324 	esac
325 	],[
326 	PYTHONFRAMEWORK=
327 	PYTHONFRAMEWORKDIR=no-framework
328 	PYTHONFRAMEWORKPREFIX=
329 	PYTHONFRAMEWORKINSTALLDIR=
330 	FRAMEWORKINSTALLFIRST=
331 	FRAMEWORKINSTALLLAST=
332 	FRAMEWORKALTINSTALLFIRST=
333 	FRAMEWORKALTINSTALLLAST=
334 	FRAMEWORKPYTHONW=
335 	if test "x${prefix}" = "xNONE" ; then
336 		FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
337 	else
338 		FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
339 	fi
340 	enable_framework=
341 
342 ])
343 AC_SUBST(PYTHONFRAMEWORK)
344 AC_SUBST(PYTHONFRAMEWORKIDENTIFIER)
345 AC_SUBST(PYTHONFRAMEWORKDIR)
346 AC_SUBST(PYTHONFRAMEWORKPREFIX)
347 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
348 AC_SUBST(FRAMEWORKINSTALLFIRST)
349 AC_SUBST(FRAMEWORKINSTALLLAST)
350 AC_SUBST(FRAMEWORKALTINSTALLFIRST)
351 AC_SUBST(FRAMEWORKALTINSTALLLAST)
352 AC_SUBST(FRAMEWORKPYTHONW)
353 AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX)
354 AC_SUBST(FRAMEWORKINSTALLAPPSPREFIX)
355 
356 AC_DEFINE_UNQUOTED(_PYTHONFRAMEWORK, "${PYTHONFRAMEWORK}", [framework name])
357 
358 ##AC_ARG_WITH(dyld,
359 ##            AS_HELP_STRING([--with-dyld],
360 ##                           [Use (OpenStep|Rhapsody) dynamic linker]))
361 ##
362 # Set name for machine-dependent library files
363 AC_ARG_VAR([MACHDEP], [name for machine-dependent library files])
364 AC_MSG_CHECKING(MACHDEP)
365 if test -z "$MACHDEP"
366 then
367     # avoid using uname for cross builds
368     if test "$cross_compiling" = yes; then
369        # ac_sys_system and ac_sys_release are used for setting
370        # a lot of different things including 'define_xopen_source'
371        # in the case statement below.
372 	case "$host" in
373 	*-*-linux-android*)
374 		ac_sys_system=Linux-android
375 		;;
376 	*-*-linux*)
377 		ac_sys_system=Linux
378 		;;
379 	*-*-cygwin*)
380 		ac_sys_system=Cygwin
381 		;;
382 	*)
383 		# for now, limit cross builds to known configurations
384 		MACHDEP="unknown"
385 		AC_MSG_ERROR([cross build not supported for $host])
386 	esac
387 	ac_sys_release=
388     else
389 	ac_sys_system=`uname -s`
390 	if test "$ac_sys_system" = "AIX" \
391 	-o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
392 		ac_sys_release=`uname -v`
393 	else
394 		ac_sys_release=`uname -r`
395 	fi
396     fi
397     ac_md_system=`echo $ac_sys_system |
398 			tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
399     ac_md_release=`echo $ac_sys_release |
400 			tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
401     MACHDEP="$ac_md_system$ac_md_release"
402 
403     case $MACHDEP in
404 	linux*) MACHDEP="linux";;
405 	cygwin*) MACHDEP="cygwin";;
406 	darwin*) MACHDEP="darwin";;
407 	'')	MACHDEP="unknown";;
408     esac
409 fi
410 
411 AC_SUBST(_PYTHON_HOST_PLATFORM)
412 if test "$cross_compiling" = yes; then
413 	case "$host" in
414 	*-*-linux*)
415 		case "$host_cpu" in
416 		arm*)
417 			_host_cpu=arm
418 			;;
419 		*)
420 			_host_cpu=$host_cpu
421 		esac
422 		;;
423 	*-*-cygwin*)
424 		_host_cpu=
425 		;;
426 	*)
427 		# for now, limit cross builds to known configurations
428 		MACHDEP="unknown"
429 		AC_MSG_ERROR([cross build not supported for $host])
430 	esac
431 	_PYTHON_HOST_PLATFORM="$MACHDEP${_host_cpu:+-$_host_cpu}"
432 fi
433 
434 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
435 # disable features if it is defined, without any means to access these
436 # features as extensions. For these systems, we skip the definition of
437 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
438 # some feature, make sure there is no alternative way to access this
439 # feature. Also, when using wildcards, make sure you have verified the
440 # need for not defining _XOPEN_SOURCE on all systems matching the
441 # wildcard, and that the wildcard does not include future systems
442 # (which may remove their limitations).
443 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
444 case $ac_sys_system/$ac_sys_release in
445   # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
446   # even though select is a POSIX function. Reported by J. Ribbens.
447   # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
448   # In addition, Stefan Krah confirms that issue #1244610 exists through
449   # OpenBSD 4.6, but is fixed in 4.7.
450   OpenBSD/2.* | OpenBSD/3.* | OpenBSD/4.@<:@0123456@:>@)
451     define_xopen_source=no
452     # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
453     # also defined. This can be overridden by defining _BSD_SOURCE
454     # As this has a different meaning on Linux, only define it on OpenBSD
455     AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
456     ;;
457   OpenBSD/*)
458     # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
459     # also defined. This can be overridden by defining _BSD_SOURCE
460     # As this has a different meaning on Linux, only define it on OpenBSD
461     AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
462     ;;
463   # Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
464   # _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
465   # Marc Recht
466   NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6@<:@A-S@:>@)
467     define_xopen_source=no;;
468   # From the perspective of Solaris, _XOPEN_SOURCE is not so much a
469   # request to enable features supported by the standard as a request
470   # to disable features not supported by the standard.  The best way
471   # for Python to use Solaris is simply to leave _XOPEN_SOURCE out
472   # entirely and define __EXTENSIONS__ instead.
473   SunOS/*)
474     define_xopen_source=no;;
475   # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
476   # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
477   # Reconfirmed for 7.1.4 by Martin v. Loewis.
478   OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
479     define_xopen_source=no;;
480   # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
481   # but used in struct sockaddr.sa_family. Reported by Tim Rice.
482   SCO_SV/3.2)
483     define_xopen_source=no;;
484   # On MacOS X 10.2, a bug in ncurses.h means that it craps out if
485   # _XOPEN_EXTENDED_SOURCE is defined. Apparently, this is fixed in 10.3, which
486   # identifies itself as Darwin/7.*
487   # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
488   # disables platform specific features beyond repair.
489   # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
490   # has no effect, don't bother defining them
491   Darwin/@<:@6789@:>@.*)
492     define_xopen_source=no;;
493   Darwin/1@<:@0-9@:>@.*)
494     define_xopen_source=no;;
495   # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
496   # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
497   # or has another value. By not (re)defining it, the defaults come in place.
498   AIX/4)
499     define_xopen_source=no;;
500   AIX/5)
501     if test `uname -r` -eq 1; then
502       define_xopen_source=no
503     fi
504     ;;
505   # On QNX 6.3.2, defining _XOPEN_SOURCE prevents netdb.h from
506   # defining NI_NUMERICHOST.
507   QNX/6.3.2)
508     define_xopen_source=no
509     ;;
510 
511 esac
512 
513 if test $define_xopen_source = yes
514 then
515   # X/Open 7, incorporating POSIX.1-2008
516   AC_DEFINE(_XOPEN_SOURCE, 700,
517             Define to the level of X/Open that your system supports)
518 
519   # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
520   # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
521   # several APIs are not declared. Since this is also needed in some
522   # cases for HP-UX, we define it globally.
523   AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
524    	    Define to activate Unix95-and-earlier features)
525 
526   AC_DEFINE(_POSIX_C_SOURCE, 200809L, Define to activate features from IEEE Stds 1003.1-2008)
527 fi
528 
529 # On HP-UX mbstate_t requires _INCLUDE__STDC_A1_SOURCE
530 case $ac_sys_system in
531   hp*|HP*)
532     define_stdc_a1=yes;;
533   *)
534     define_stdc_a1=no;;
535 esac
536 
537 if test $define_stdc_a1 = yes
538 then
539   AC_DEFINE(_INCLUDE__STDC_A1_SOURCE, 1, Define to include mbstate_t for mbrtowc)
540 fi
541 
542 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
543 # it may influence the way we can build extensions, so distutils
544 # needs to check it
545 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
546 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
547 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
548 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
549 
550 # checks for alternative programs
551 
552 # compiler flags are generated in two sets, BASECFLAGS and OPT.  OPT is just
553 # for debug/optimization stuff.  BASECFLAGS is for flags that are required
554 # just to get things to compile and link.  Users are free to override OPT
555 # when running configure or make.  The build should not break if they do.
556 # BASECFLAGS should generally not be messed with, however.
557 
558 # XXX shouldn't some/most/all of this code be merged with the stuff later
559 # on that fiddles with OPT and BASECFLAGS?
560 AC_MSG_CHECKING(for --without-gcc)
561 AC_ARG_WITH(gcc,
562             AS_HELP_STRING([--without-gcc], [never use gcc]),
563 [
564 	case $withval in
565 	no)	CC=${CC:-cc}
566 		without_gcc=yes;;
567 	yes)	CC=gcc
568 		without_gcc=no;;
569 	*)	CC=$withval
570 		without_gcc=$withval;;
571 	esac], [
572 	case $ac_sys_system in
573 	AIX*)   CC=${CC:-xlc_r}
574 		without_gcc=;;
575 	*)	without_gcc=no;;
576 	esac])
577 AC_MSG_RESULT($without_gcc)
578 
579 AC_MSG_CHECKING(for --with-icc)
580 AC_ARG_WITH(icc,
581             AS_HELP_STRING([--with-icc], [build with icc]),
582 [
583 	case $withval in
584 	no)	CC=${CC:-cc}
585 		with_icc=no;;
586 	yes)	CC=icc
587 		CXX=icpc
588 		with_icc=yes;;
589 	*)	CC=$withval
590 		with_icc=$withval;;
591 	esac], [
592 	with_icc=no])
593 AC_MSG_RESULT($with_icc)
594 
595 # If the user switches compilers, we can't believe the cache
596 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
597 then
598   AC_MSG_ERROR([cached CC is different -- throw away $cache_file
599 (it is also a good idea to do 'make clean' before compiling)])
600 fi
601 
602 # Don't let AC_PROG_CC set the default CFLAGS. It normally sets -g -O2
603 # when the compiler supports them, but we don't always want -O2, and
604 # we set -g later.
605 if test -z "$CFLAGS"; then
606         CFLAGS=
607 fi
608 
609 if test "$ac_sys_system" = "Darwin"
610 then
611 	# Compiler selection on MacOSX is more complicated than
612 	# AC_PROG_CC can handle, see Mac/README for more
613 	# information
614 	if test -z "${CC}"
615 	then
616 		found_gcc=
617 		found_clang=
618 		as_save_IFS=$IFS; IFS=:
619 		for as_dir in $PATH
620 		do
621 			IFS=$as_save_IFS
622 			if test -x "${as_dir}/gcc"; then
623 				if test -z "${found_gcc}"; then
624 					found_gcc="${as_dir}/gcc"
625 				fi
626 			fi
627 			if test -x "${as_dir}/clang"; then
628 				if test -z "${found_clang}"; then
629 					found_clang="${as_dir}/clang"
630 				fi
631 			fi
632 		done
633 		IFS=$as_save_IFS
634 
635 		if test -n "$found_gcc" -a -n "$found_clang"
636 		then
637 			if test -n "`"$found_gcc" --version | grep llvm-gcc`"
638 			then
639 				AC_MSG_NOTICE([Detected llvm-gcc, falling back to clang])
640 				CC="$found_clang"
641 				CXX="$found_clang++"
642 			fi
643 
644 
645 		elif test -z "$found_gcc" -a -n "$found_clang"
646 		then
647 			AC_MSG_NOTICE([No GCC found, use CLANG])
648 			CC="$found_clang"
649 			CXX="$found_clang++"
650 
651 		elif test -z "$found_gcc" -a -z "$found_clang"
652 		then
653 			found_clang=`/usr/bin/xcrun -find clang 2>/dev/null`
654 			if test -n "${found_clang}"
655 			then
656 				AC_MSG_NOTICE([Using clang from Xcode.app])
657 				CC="${found_clang}"
658 				CXX="`/usr/bin/xcrun -find clang++`"
659 
660 			# else: use default behaviour
661 			fi
662 		fi
663 	fi
664 fi
665 AC_PROG_CC
666 AC_PROG_CPP
667 AC_PROG_GREP
668 AC_PROG_SED
669 
670 AC_SUBST(CXX)
671 AC_SUBST(MAINCC)
672 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
673 AC_ARG_WITH(cxx_main,
674             AS_HELP_STRING([--with-cxx-main=<compiler>],
675                            [compile main() and link python executable with C++ compiler]),
676 [
677 
678 	case $withval in
679 	no)	with_cxx_main=no
680 		MAINCC='$(CC)';;
681 	yes)	with_cxx_main=yes
682 		MAINCC='$(CXX)';;
683 	*)	with_cxx_main=yes
684 		MAINCC=$withval
685 		if test -z "$CXX"
686 		then
687 			CXX=$withval
688 		fi;;
689 	esac], [
690 	with_cxx_main=no
691 	MAINCC='$(CC)'
692 ])
693 AC_MSG_RESULT($with_cxx_main)
694 
695 preset_cxx="$CXX"
696 if test -z "$CXX"
697 then
698         case "$CC" in
699         gcc)    AC_PATH_TOOL(CXX, [g++], [g++], [notfound]) ;;
700         cc)     AC_PATH_TOOL(CXX, [c++], [c++], [notfound]) ;;
701         clang|*/clang)     AC_PATH_TOOL(CXX, [clang++], [clang++], [notfound]) ;;
702         icc|*/icc)         AC_PATH_TOOL(CXX, [icpc], [icpc], [notfound]) ;;
703         esac
704 	if test "$CXX" = "notfound"
705 	then
706 		CXX=""
707 	fi
708 fi
709 if test -z "$CXX"
710 then
711 	AC_CHECK_TOOLS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
712 	if test "$CXX" = "notfound"
713 	then
714 		CXX=""
715 	fi
716 fi
717 if test "$preset_cxx" != "$CXX"
718 then
719         AC_MSG_NOTICE([
720 
721   By default, distutils will build C++ extension modules with "$CXX".
722   If this is not intended, then set CXX on the configure command line.
723   ])
724 fi
725 
726 
727 MULTIARCH=$($CC --print-multiarch 2>/dev/null)
728 AC_SUBST(MULTIARCH)
729 
730 AC_MSG_CHECKING([for the platform triplet based on compiler characteristics])
731 cat >> conftest.c <<EOF
732 #undef bfin
733 #undef cris
734 #undef fr30
735 #undef linux
736 #undef hppa
737 #undef hpux
738 #undef i386
739 #undef mips
740 #undef powerpc
741 #undef sparc
742 #undef unix
743 #if defined(__ANDROID__)
744     # Android is not a multiarch system.
745 #elif defined(__linux__)
746 # if defined(__x86_64__) && defined(__LP64__)
747         x86_64-linux-gnu
748 # elif defined(__x86_64__) && defined(__ILP32__)
749         x86_64-linux-gnux32
750 # elif defined(__i386__)
751         i386-linux-gnu
752 # elif defined(__aarch64__) && defined(__AARCH64EL__)
753 #  if defined(__ILP32__)
754         aarch64_ilp32-linux-gnu
755 #  else
756         aarch64-linux-gnu
757 #  endif
758 # elif defined(__aarch64__) && defined(__AARCH64EB__)
759 #  if defined(__ILP32__)
760         aarch64_be_ilp32-linux-gnu
761 #  else
762         aarch64_be-linux-gnu
763 #  endif
764 # elif defined(__alpha__)
765         alpha-linux-gnu
766 # elif defined(__ARM_EABI__) && defined(__ARM_PCS_VFP)
767 #  if defined(__ARMEL__)
768         arm-linux-gnueabihf
769 #  else
770         armeb-linux-gnueabihf
771 #  endif
772 # elif defined(__ARM_EABI__) && !defined(__ARM_PCS_VFP)
773 #  if defined(__ARMEL__)
774         arm-linux-gnueabi
775 #  else
776         armeb-linux-gnueabi
777 #  endif
778 # elif defined(__hppa__)
779         hppa-linux-gnu
780 # elif defined(__ia64__)
781         ia64-linux-gnu
782 # elif defined(__m68k__) && !defined(__mcoldfire__)
783         m68k-linux-gnu
784 # elif defined(__mips_hard_float) && defined(__mips_isa_rev) && (__mips_isa_rev >=6) && defined(_MIPSEL)
785 #  if _MIPS_SIM == _ABIO32
786         mipsisa32r6el-linux-gnu
787 #  elif _MIPS_SIM == _ABIN32
788         mipsisa64r6el-linux-gnuabin32
789 #  elif _MIPS_SIM == _ABI64
790         mipsisa64r6el-linux-gnuabi64
791 #  else
792 #   error unknown platform triplet
793 #  endif
794 # elif defined(__mips_hard_float) && defined(__mips_isa_rev) && (__mips_isa_rev >=6)
795 #  if _MIPS_SIM == _ABIO32
796         mipsisa32r6-linux-gnu
797 #  elif _MIPS_SIM == _ABIN32
798         mipsisa64r6-linux-gnuabin32
799 #  elif _MIPS_SIM == _ABI64
800         mipsisa64r6-linux-gnuabi64
801 #  else
802 #   error unknown platform triplet
803 #  endif
804 # elif defined(__mips_hard_float) && defined(_MIPSEL)
805 #  if _MIPS_SIM == _ABIO32
806         mipsel-linux-gnu
807 #  elif _MIPS_SIM == _ABIN32
808         mips64el-linux-gnuabin32
809 #  elif _MIPS_SIM == _ABI64
810         mips64el-linux-gnuabi64
811 #  else
812 #   error unknown platform triplet
813 #  endif
814 # elif defined(__mips_hard_float)
815 #  if _MIPS_SIM == _ABIO32
816         mips-linux-gnu
817 #  elif _MIPS_SIM == _ABIN32
818         mips64-linux-gnuabin32
819 #  elif _MIPS_SIM == _ABI64
820         mips64-linux-gnuabi64
821 #  else
822 #   error unknown platform triplet
823 #  endif
824 # elif defined(__or1k__)
825         or1k-linux-gnu
826 # elif defined(__powerpc__) && defined(__SPE__)
827         powerpc-linux-gnuspe
828 # elif defined(__powerpc64__)
829 #  if defined(__LITTLE_ENDIAN__)
830         powerpc64le-linux-gnu
831 #  else
832         powerpc64-linux-gnu
833 #  endif
834 # elif defined(__powerpc__)
835         powerpc-linux-gnu
836 # elif defined(__s390x__)
837         s390x-linux-gnu
838 # elif defined(__s390__)
839         s390-linux-gnu
840 # elif defined(__sh__) && defined(__LITTLE_ENDIAN__)
841         sh4-linux-gnu
842 # elif defined(__sparc__) && defined(__arch64__)
843         sparc64-linux-gnu
844 # elif defined(__sparc__)
845         sparc-linux-gnu
846 # elif defined(__riscv)
847 #  if __riscv_xlen == 32
848         riscv32-linux-gnu
849 #  elif __riscv_xlen == 64
850         riscv64-linux-gnu
851 #  else
852 #   error unknown platform triplet
853 #  endif
854 # else
855 #   error unknown platform triplet
856 # endif
857 #elif defined(__FreeBSD_kernel__)
858 # if defined(__LP64__)
859         x86_64-kfreebsd-gnu
860 # elif defined(__i386__)
861         i386-kfreebsd-gnu
862 # else
863 #   error unknown platform triplet
864 # endif
865 #elif defined(__gnu_hurd__)
866         i386-gnu
867 #elif defined(__APPLE__)
868         darwin
869 #else
870 # error unknown platform triplet
871 #endif
872 
873 EOF
874 
875 if $CPP $CPPFLAGS conftest.c >conftest.out 2>/dev/null; then
876   PLATFORM_TRIPLET=`grep -v '^#' conftest.out | grep -v '^ *$' | tr -d ' 	'`
877   AC_MSG_RESULT([$PLATFORM_TRIPLET])
878 else
879   AC_MSG_RESULT([none])
880 fi
881 rm -f conftest.c conftest.out
882 
883 if test x$PLATFORM_TRIPLET != x && test x$MULTIARCH != x; then
884   if test x$PLATFORM_TRIPLET != x$MULTIARCH; then
885     AC_MSG_ERROR([internal configure error for the platform triplet, please file a bug report])
886   fi
887 elif test x$PLATFORM_TRIPLET != x && test x$MULTIARCH = x; then
888   MULTIARCH=$PLATFORM_TRIPLET
889 fi
890 AC_SUBST(PLATFORM_TRIPLET)
891 if test x$MULTIARCH != x; then
892   MULTIARCH_CPPFLAGS="-DMULTIARCH=\\\"$MULTIARCH\\\""
893 fi
894 AC_SUBST(MULTIARCH_CPPFLAGS)
895 
896 AC_MSG_CHECKING([for -Wl,--no-as-needed])
897 save_LDFLAGS="$LDFLAGS"
898 LDFLAGS="$LDFLAGS -Wl,--no-as-needed"
899 AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
900   [NO_AS_NEEDED="-Wl,--no-as-needed"
901    AC_MSG_RESULT([yes])],
902   [NO_AS_NEEDED=""
903    AC_MSG_RESULT([no])])
904 LDFLAGS="$save_LDFLAGS"
905 AC_SUBST(NO_AS_NEEDED)
906 
907 
908 # checks for UNIX variants that set C preprocessor variables
909 AC_USE_SYSTEM_EXTENSIONS
910 
911 AC_MSG_CHECKING([for the Android API level])
912 cat >> conftest.c <<EOF
913 #ifdef __ANDROID__
914 android_api = __ANDROID_API__
915 arm_arch = __ARM_ARCH
916 #else
917 #error not Android
918 #endif
919 EOF
920 
921 if $CPP $CPPFLAGS conftest.c >conftest.out 2>/dev/null; then
922   ANDROID_API_LEVEL=`sed -n -e '/__ANDROID_API__/d' -e 's/^android_api = //p' conftest.out`
923   _arm_arch=`sed -n -e '/__ARM_ARCH/d' -e 's/^arm_arch = //p' conftest.out`
924   AC_MSG_RESULT([$ANDROID_API_LEVEL])
925   if test -z "$ANDROID_API_LEVEL"; then
926     echo 'Fatal: you must define __ANDROID_API__'
927     exit 1
928   fi
929   AC_DEFINE_UNQUOTED(ANDROID_API_LEVEL, $ANDROID_API_LEVEL, [The Android API level.])
930 
931   AC_MSG_CHECKING([for the Android arm ABI])
932   AC_MSG_RESULT([$_arm_arch])
933   if test "$_arm_arch" = 7; then
934     BASECFLAGS="${BASECFLAGS} -mfloat-abi=softfp -mfpu=vfpv3-d16"
935     LDFLAGS="${LDFLAGS} -march=armv7-a -Wl,--fix-cortex-a8"
936   fi
937 else
938   AC_MSG_RESULT([not Android])
939 fi
940 rm -f conftest.c conftest.out
941 
942 # Check for unsupported systems
943 case $ac_sys_system/$ac_sys_release in
944 atheos*|Linux*/1*)
945    echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
946    echo See README for details.
947    exit 1;;
948 esac
949 
950 AC_EXEEXT
951 AC_MSG_CHECKING(for --with-suffix)
952 AC_ARG_WITH(suffix,
953             AS_HELP_STRING([--with-suffix=.exe], [set executable suffix]),
954 [
955 	case $withval in
956 	no)	EXEEXT=;;
957 	yes)	EXEEXT=.exe;;
958 	*)	EXEEXT=$withval;;
959 	esac])
960 AC_MSG_RESULT($EXEEXT)
961 
962 # Test whether we're running on a non-case-sensitive system, in which
963 # case we give a warning if no ext is given
964 AC_SUBST(BUILDEXEEXT)
965 AC_MSG_CHECKING(for case-insensitive build directory)
966 if test ! -d CaseSensitiveTestDir; then
967 mkdir CaseSensitiveTestDir
968 fi
969 
970 if test -d casesensitivetestdir
971 then
972     AC_MSG_RESULT(yes)
973     BUILDEXEEXT=.exe
974 else
975 	AC_MSG_RESULT(no)
976 	BUILDEXEEXT=$EXEEXT
977 fi
978 rmdir CaseSensitiveTestDir
979 
980 case $ac_sys_system in
981 hp*|HP*)
982     case $CC in
983     cc|*/cc) CC="$CC -Ae";;
984     esac;;
985 esac
986 
987 AC_SUBST(LIBRARY)
988 AC_MSG_CHECKING(LIBRARY)
989 if test -z "$LIBRARY"
990 then
991 	LIBRARY='libpython$(VERSION)$(ABIFLAGS).a'
992 fi
993 AC_MSG_RESULT($LIBRARY)
994 
995 # LDLIBRARY is the name of the library to link against (as opposed to the
996 # name of the library into which to insert object files). BLDLIBRARY is also
997 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
998 # is blank as the main program is not linked directly against LDLIBRARY.
999 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
1000 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
1001 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
1002 # DLLLIBRARY is the shared (i.e., DLL) library.
1003 #
1004 # RUNSHARED is used to run shared python without installed libraries
1005 #
1006 # INSTSONAME is the name of the shared library that will be use to install
1007 # on the system - some systems like version suffix, others don't
1008 #
1009 # LDVERSION is the shared library version number, normally the Python version
1010 # with the ABI build flags appended.
1011 AC_SUBST(LDLIBRARY)
1012 AC_SUBST(DLLLIBRARY)
1013 AC_SUBST(BLDLIBRARY)
1014 AC_SUBST(PY3LIBRARY)
1015 AC_SUBST(LDLIBRARYDIR)
1016 AC_SUBST(INSTSONAME)
1017 AC_SUBST(RUNSHARED)
1018 AC_SUBST(LDVERSION)
1019 LDLIBRARY="$LIBRARY"
1020 BLDLIBRARY='$(LDLIBRARY)'
1021 INSTSONAME='$(LDLIBRARY)'
1022 DLLLIBRARY=''
1023 LDLIBRARYDIR=''
1024 RUNSHARED=''
1025 LDVERSION="$VERSION"
1026 
1027 # LINKCC is the command that links the python executable -- default is $(CC).
1028 # If CXX is set, and if it is needed to link a main function that was
1029 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
1030 # python might then depend on the C++ runtime
1031 # This is altered for AIX in order to build the export list before
1032 # linking.
1033 AC_SUBST(LINKCC)
1034 AC_MSG_CHECKING(LINKCC)
1035 if test -z "$LINKCC"
1036 then
1037 	LINKCC='$(PURIFY) $(MAINCC)'
1038 	case $ac_sys_system in
1039 	AIX*)
1040 	   exp_extra="\"\""
1041 	   if test $ac_sys_release -ge 5 -o \
1042 		   $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
1043 	       exp_extra="."
1044 	   fi
1045 	   LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
1046 	QNX*)
1047 	   # qcc must be used because the other compilers do not
1048 	   # support -N.
1049 	   LINKCC=qcc;;
1050 	esac
1051 fi
1052 AC_MSG_RESULT($LINKCC)
1053 
1054 # GNULD is set to "yes" if the GNU linker is used.  If this goes wrong
1055 # make sure we default having it set to "no": this is used by
1056 # distutils.unixccompiler to know if it should add --enable-new-dtags
1057 # to linker command lines, and failing to detect GNU ld simply results
1058 # in the same bahaviour as before.
1059 AC_SUBST(GNULD)
1060 AC_MSG_CHECKING(for GNU ld)
1061 ac_prog=ld
1062 if test "$GCC" = yes; then
1063        ac_prog=`$CC -print-prog-name=ld`
1064 fi
1065 case `"$ac_prog" -V 2>&1 < /dev/null` in
1066       *GNU*)
1067           GNULD=yes;;
1068       *)
1069           GNULD=no;;
1070 esac
1071 AC_MSG_RESULT($GNULD)
1072 
1073 AC_MSG_CHECKING(for --enable-shared)
1074 AC_ARG_ENABLE(shared,
1075               AS_HELP_STRING([--enable-shared], [disable/enable building shared python library]))
1076 
1077 if test -z "$enable_shared"
1078 then
1079   case $ac_sys_system in
1080   CYGWIN*)
1081     enable_shared="yes";;
1082   *)
1083     enable_shared="no";;
1084   esac
1085 fi
1086 AC_MSG_RESULT($enable_shared)
1087 
1088 AC_MSG_CHECKING(for --enable-profiling)
1089 AC_ARG_ENABLE(profiling,
1090               AS_HELP_STRING([--enable-profiling], [enable C-level code profiling]))
1091 if test "x$enable_profiling" = xyes; then
1092   ac_save_cc="$CC"
1093   CC="$CC -pg"
1094   AC_LINK_IFELSE([AC_LANG_SOURCE([[int main() { return 0; }]])],
1095     [],
1096     [enable_profiling=no])
1097   CC="$ac_save_cc"
1098 else
1099   enable_profiling=no
1100 fi
1101 AC_MSG_RESULT($enable_profiling)
1102 
1103 if test "x$enable_profiling" = xyes; then
1104   BASECFLAGS="-pg $BASECFLAGS"
1105   LDFLAGS="-pg $LDFLAGS"
1106 fi
1107 
1108 AC_MSG_CHECKING(LDLIBRARY)
1109 
1110 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
1111 # library that we build, but we do not want to link against it (we
1112 # will find it with a -framework option). For this reason there is an
1113 # extra variable BLDLIBRARY against which Python and the extension
1114 # modules are linked, BLDLIBRARY. This is normally the same as
1115 # LDLIBRARY, but empty for MacOSX framework builds.
1116 if test "$enable_framework"
1117 then
1118   LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1119   RUNSHARED=DYLD_FRAMEWORK_PATH=`pwd`${DYLD_FRAMEWORK_PATH:+:${DYLD_FRAMEWORK_PATH}}
1120   BLDLIBRARY=''
1121 else
1122   BLDLIBRARY='$(LDLIBRARY)'
1123 fi
1124 
1125 # Other platforms follow
1126 if test $enable_shared = "yes"; then
1127   PY_ENABLE_SHARED=1
1128   AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
1129   case $ac_sys_system in
1130     CYGWIN*)
1131           LDLIBRARY='libpython$(LDVERSION).dll.a'
1132           DLLLIBRARY='libpython$(LDVERSION).dll'
1133           ;;
1134     SunOS*)
1135 	  LDLIBRARY='libpython$(LDVERSION).so'
1136 	  BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(LDVERSION)'
1137 	  RUNSHARED=LD_LIBRARY_PATH=`pwd`${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}
1138 	  INSTSONAME="$LDLIBRARY".$SOVERSION
1139 	  if test "$with_pydebug" != yes
1140 	  then
1141 	      PY3LIBRARY=libpython3.so
1142 	  fi
1143           ;;
1144     Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*|OpenBSD*)
1145 	  LDLIBRARY='libpython$(LDVERSION).so'
1146 	  BLDLIBRARY='-L. -lpython$(LDVERSION)'
1147 	  RUNSHARED=LD_LIBRARY_PATH=`pwd`${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}
1148 	  INSTSONAME="$LDLIBRARY".$SOVERSION
1149 	  if test "$with_pydebug" != yes
1150           then
1151 	      PY3LIBRARY=libpython3.so
1152 	  fi
1153 	  ;;
1154     hp*|HP*)
1155 	  case `uname -m` in
1156 		ia64)
1157 			LDLIBRARY='libpython$(LDVERSION).so'
1158 			;;
1159 		*)
1160 			LDLIBRARY='libpython$(LDVERSION).sl'
1161 			;;
1162 	  esac
1163 	  BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(LDVERSION)'
1164 	  RUNSHARED=SHLIB_PATH=`pwd`${SHLIB_PATH:+:${SHLIB_PATH}}
1165 	  ;;
1166     Darwin*)
1167     	LDLIBRARY='libpython$(LDVERSION).dylib'
1168 	BLDLIBRARY='-L. -lpython$(LDVERSION)'
1169 	RUNSHARED=DYLD_LIBRARY_PATH=`pwd`${DYLD_LIBRARY_PATH:+:${DYLD_LIBRARY_PATH}}
1170 	;;
1171     AIX*)
1172 	LDLIBRARY='libpython$(LDVERSION).so'
1173 	RUNSHARED=LIBPATH=`pwd`${LIBPATH:+:${LIBPATH}}
1174 	;;
1175 
1176   esac
1177 else # shared is disabled
1178   PY_ENABLE_SHARED=0
1179   case $ac_sys_system in
1180     CYGWIN*)
1181           BLDLIBRARY='$(LIBRARY)'
1182           LDLIBRARY='libpython$(LDVERSION).dll.a'
1183           ;;
1184   esac
1185 fi
1186 
1187 if test "$cross_compiling" = yes; then
1188 	RUNSHARED=
1189 fi
1190 
1191 AC_MSG_RESULT($LDLIBRARY)
1192 
1193 AC_SUBST(AR)
1194 AC_CHECK_TOOLS(AR, ar aal, ar)
1195 
1196 # tweak ARFLAGS only if the user didn't set it on the command line
1197 AC_SUBST(ARFLAGS)
1198 if test -z "$ARFLAGS"
1199 then
1200         ARFLAGS="rcs"
1201 fi
1202 
1203 AC_CHECK_TOOLS([READELF], [readelf], [:])
1204 if test "$cross_compiling" = yes; then
1205     case "$READELF" in
1206 	readelf|:)
1207 	AC_MSG_ERROR([readelf for the host is required for cross builds])
1208 	;;
1209     esac
1210 fi
1211 AC_SUBST(READELF)
1212 
1213 
1214 case $MACHDEP in
1215 hp*|HP*)
1216 	# install -d does not work on HP-UX
1217 	if test -z "$INSTALL"
1218 	then
1219 		INSTALL="${srcdir}/install-sh -c"
1220 	fi
1221 esac
1222 AC_PROG_INSTALL
1223 AC_PROG_MKDIR_P
1224 
1225 # Not every filesystem supports hard links
1226 AC_SUBST(LN)
1227 if test -z "$LN" ; then
1228 	case $ac_sys_system in
1229 		CYGWIN*) LN="ln -s";;
1230 		*) LN=ln;;
1231 	esac
1232 fi
1233 
1234 # For calculating the .so ABI tag.
1235 AC_SUBST(ABIFLAGS)
1236 ABIFLAGS=""
1237 
1238 # Check for --with-pydebug
1239 AC_MSG_CHECKING(for --with-pydebug)
1240 AC_ARG_WITH(pydebug,
1241             AS_HELP_STRING([--with-pydebug], [build with Py_DEBUG defined]),
1242 [
1243 if test "$withval" != no
1244 then
1245   AC_DEFINE(Py_DEBUG, 1,
1246   [Define if you want to build an interpreter with many run-time checks.])
1247   AC_MSG_RESULT(yes);
1248   Py_DEBUG='true'
1249   ABIFLAGS="${ABIFLAGS}d"
1250 else AC_MSG_RESULT(no); Py_DEBUG='false'
1251 fi],
1252 [AC_MSG_RESULT(no)])
1253 
1254 # Check for --with-assertions. Py_DEBUG implies assertions, but also changes
1255 # the ABI. This allows enabling assertions without changing the ABI.
1256 assertions='false'
1257 AC_MSG_CHECKING(for --with-assertions)
1258 AC_ARG_WITH(assertions,
1259             AC_HELP_STRING([--with-assertions], [build with C assertions enabled]),
1260 [
1261 if test "$withval" != no
1262 then
1263   assertions='true'
1264 fi],
1265 [])
1266 if test "$assertions" = 'true'; then
1267   AC_MSG_RESULT(yes)
1268 elif test "$Py_DEBUG" = 'true'; then
1269   assertions='true'
1270   AC_MSG_RESULT(implied by --with-pydebug)
1271 else
1272   AC_MSG_RESULT(no)
1273 fi
1274 
1275 # Enable optimization flags
1276 AC_SUBST(DEF_MAKE_ALL_RULE)
1277 AC_SUBST(DEF_MAKE_RULE)
1278 Py_OPT='false'
1279 AC_MSG_CHECKING(for --enable-optimizations)
1280 AC_ARG_ENABLE(optimizations, AS_HELP_STRING([--enable-optimizations], [Enable expensive, stable optimizations (PGO, etc).  Disabled by default.]),
1281 [
1282 if test "$enableval" != no
1283 then
1284   Py_OPT='true'
1285   AC_MSG_RESULT(yes);
1286 else
1287   Py_OPT='false'
1288   AC_MSG_RESULT(no);
1289 fi],
1290 [AC_MSG_RESULT(no)])
1291 if test "$Py_OPT" = 'true' ; then
1292   # Intentionally not forcing Py_LTO='true' here.  Too many toolchains do not
1293   # compile working code using it and both test_distutils and test_gdb are
1294   # broken when you do manage to get a toolchain that works with it.  People
1295   # who want LTO need to use --with-lto themselves.
1296   DEF_MAKE_ALL_RULE="profile-opt"
1297   REQUIRE_PGO="yes"
1298   DEF_MAKE_RULE="build_all"
1299 else
1300   DEF_MAKE_ALL_RULE="build_all"
1301   REQUIRE_PGO="no"
1302   DEF_MAKE_RULE="all"
1303 fi
1304 
1305 # Make llvm-relatec checks work on systems where llvm tools are not installed with their
1306 # normal names in the default $PATH (ie: Ubuntu).  They exist under the
1307 # non-suffixed name in their versioned llvm directory.
1308 
1309 llvm_bin_dir=''
1310 llvm_path="${PATH}"
1311 if test "${CC}" = "clang"
1312 then
1313   clang_bin=`which clang`
1314   # Some systems install clang elsewhere as a symlink to the real path
1315   # which is where the related llvm tools are located.
1316   if test -L "${clang_bin}"
1317   then
1318     clang_dir=`dirname "${clang_bin}"`
1319     clang_bin=`readlink "${clang_bin}"`
1320     llvm_bin_dir="${clang_dir}/"`dirname "${clang_bin}"`
1321     llvm_path="${llvm_path}${PATH_SEPARATOR}${llvm_bin_dir}"
1322   fi
1323 fi
1324 
1325 # Enable LTO flags
1326 AC_MSG_CHECKING(for --with-lto)
1327 AC_ARG_WITH(lto, AS_HELP_STRING([--with-lto], [Enable Link Time Optimization in any build. Disabled by default.]),
1328 [
1329 if test "$withval" != no
1330 then
1331   Py_LTO='true'
1332   AC_MSG_RESULT(yes);
1333 else
1334   Py_LTO='false'
1335   AC_MSG_RESULT(no);
1336 fi],
1337 [AC_MSG_RESULT(no)])
1338 if test "$Py_LTO" = 'true' ; then
1339   case $CC in
1340     *clang*)
1341       AC_SUBST(LLVM_AR)
1342       AC_PATH_TARGET_TOOL(LLVM_AR, llvm-ar, '', ${llvm_path})
1343       AC_SUBST(LLVM_AR_FOUND)
1344       if test -n "${LLVM_AR}" -a -x "${LLVM_AR}"
1345       then
1346         LLVM_AR_FOUND="found"
1347       else
1348         LLVM_AR_FOUND="not-found"
1349       fi
1350       if test "$ac_sys_system" = "Darwin" -a "${LLVM_AR_FOUND}" = "not-found"
1351       then
1352         found_llvm_ar=`/usr/bin/xcrun -find llvm-ar 2>/dev/null`
1353         if test -n "${found_llvm_ar}"
1354         then
1355           LLVM_AR='/usr/bin/xcrun llvm-ar'
1356           LLVM_AR_FOUND=found
1357           AC_MSG_NOTICE([llvm-ar found via xcrun: ${LLVM_AR}])
1358         fi
1359       fi
1360       if test $LLVM_AR_FOUND = not-found
1361       then
1362         LLVM_PROFR_ERR=yes
1363         AC_MSG_ERROR([llvm-ar is required for a --with-lto build with clang but could not be found.])
1364       else
1365         LLVM_AR_ERR=no
1366       fi
1367       AR="${LLVM_AR}"
1368       case $ac_sys_system in
1369         Darwin*)
1370           # Any changes made here should be reflected in the GCC+Darwin case below
1371           LTOFLAGS="-flto -Wl,-export_dynamic"
1372           ;;
1373         *)
1374           LTOFLAGS="-flto"
1375           ;;
1376       esac
1377       ;;
1378     *gcc*)
1379       case $ac_sys_system in
1380         Darwin*)
1381           LTOFLAGS="-flto -Wl,-export_dynamic"
1382           ;;
1383         *)
1384           LTOFLAGS="-flto -fuse-linker-plugin -ffat-lto-objects -flto-partition=none"
1385           ;;
1386       esac
1387       ;;
1388   esac
1389 
1390   if test "$ac_cv_prog_cc_g" = "yes"
1391   then
1392       # bpo-30345: Add -g to LDFLAGS when compiling with LTO
1393       # to get debug symbols.
1394       LTOFLAGS="$LTOFLAGS -g"
1395   fi
1396 
1397   CFLAGS_NODIST="$CFLAGS_NODIST $LTOFLAGS"
1398   LDFLAGS_NODIST="$LDFLAGS_NODIST $LTOFLAGS"
1399 fi
1400 
1401 # Enable PGO flags.
1402 AC_SUBST(PGO_PROF_GEN_FLAG)
1403 AC_SUBST(PGO_PROF_USE_FLAG)
1404 AC_SUBST(LLVM_PROF_MERGER)
1405 AC_SUBST(LLVM_PROF_FILE)
1406 AC_SUBST(LLVM_PROF_ERR)
1407 AC_SUBST(LLVM_PROFDATA)
1408 AC_PATH_TARGET_TOOL(LLVM_PROFDATA, llvm-profdata, '', ${llvm_path})
1409 AC_SUBST(LLVM_PROF_FOUND)
1410 if test -n "${LLVM_PROFDATA}" -a -x "${LLVM_PROFDATA}"
1411 then
1412   LLVM_PROF_FOUND="found"
1413 else
1414   LLVM_PROF_FOUND="not-found"
1415 fi
1416 if test "$ac_sys_system" = "Darwin" -a "${LLVM_PROF_FOUND}" = "not-found"
1417 then
1418   found_llvm_profdata=`/usr/bin/xcrun -find llvm-profdata 2>/dev/null`
1419   if test -n "${found_llvm_profdata}"
1420   then
1421     # llvm-profdata isn't directly in $PATH in some cases.
1422     # https://apple.stackexchange.com/questions/197053/
1423     LLVM_PROFDATA='/usr/bin/xcrun llvm-profdata'
1424     LLVM_PROF_FOUND=found
1425     AC_MSG_NOTICE([llvm-profdata found via xcrun: ${LLVM_PROFDATA}])
1426   fi
1427 fi
1428 LLVM_PROF_ERR=no
1429 case $CC in
1430   *clang*)
1431     # Any changes made here should be reflected in the GCC+Darwin case below
1432     PGO_PROF_GEN_FLAG="-fprofile-instr-generate"
1433     PGO_PROF_USE_FLAG="-fprofile-instr-use=code.profclangd"
1434     LLVM_PROF_MERGER="${LLVM_PROFDATA} merge -output=code.profclangd *.profclangr"
1435     LLVM_PROF_FILE="LLVM_PROFILE_FILE=\"code-%p.profclangr\""
1436     if test $LLVM_PROF_FOUND = not-found
1437     then
1438       LLVM_PROF_ERR=yes
1439       if test "${REQUIRE_PGO}" = "yes"
1440       then
1441         AC_MSG_ERROR([llvm-profdata is required for a --enable-optimizations build but could not be found.])
1442       fi
1443     fi
1444     ;;
1445   *gcc*)
1446     case $ac_sys_system in
1447       Darwin*)
1448         PGO_PROF_GEN_FLAG="-fprofile-instr-generate"
1449         PGO_PROF_USE_FLAG="-fprofile-instr-use=code.profclangd"
1450         LLVM_PROF_MERGER="${LLVM_PROFDATA} merge -output=code.profclangd *.profclangr"
1451         LLVM_PROF_FILE="LLVM_PROFILE_FILE=\"code-%p.profclangr\""
1452         if test "${LLVM_PROF_FOUND}" = "not-found"
1453         then
1454           LLVM_PROF_ERR=yes
1455           if test "${REQUIRE_PGO}" = "yes"
1456 	  then
1457 	    AC_MSG_ERROR([llvm-profdata is required for a --enable-optimizations build but could not be found.])
1458 	  fi
1459         fi
1460         ;;
1461       *)
1462         PGO_PROF_GEN_FLAG="-fprofile-generate"
1463         PGO_PROF_USE_FLAG="-fprofile-use -fprofile-correction"
1464         LLVM_PROF_MERGER="true"
1465         LLVM_PROF_FILE=""
1466         ;;
1467     esac
1468     ;;
1469   *icc*)
1470     PGO_PROF_GEN_FLAG="-prof-gen"
1471     PGO_PROF_USE_FLAG="-prof-use"
1472     LLVM_PROF_MERGER="true"
1473     LLVM_PROF_FILE=""
1474     ;;
1475 esac
1476 
1477 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
1478 # merged with this chunk of code?
1479 
1480 # Optimizer/debugger flags
1481 # ------------------------
1482 # (The following bit of code is complicated enough - please keep things
1483 # indented properly.  Just pretend you're editing Python code. ;-)
1484 
1485 # There are two parallel sets of case statements below, one that checks to
1486 # see if OPT was set and one that does BASECFLAGS setting based upon
1487 # compiler and platform.  BASECFLAGS tweaks need to be made even if the
1488 # user set OPT.
1489 
1490 # tweak OPT based on compiler and platform, only if the user didn't set
1491 # it on the command line
1492 AC_SUBST(OPT)
1493 AC_SUBST(CFLAGS_ALIASING)
1494 if test "${OPT-unset}" = "unset"
1495 then
1496     case $GCC in
1497     yes)
1498         # For gcc 4.x we need to use -fwrapv so lets check if its supported
1499         if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
1500            WRAP="-fwrapv"
1501         fi
1502 
1503         case $CC in
1504             *clang*)
1505                 cc_is_clang=1
1506                 ;;
1507             *)
1508                 if $CC --version 2>&1 | grep -q clang
1509                 then
1510                     cc_is_clang=1
1511                 else
1512                     cc_is_clang=
1513                 fi
1514         esac
1515 
1516         if test -n "${cc_is_clang}"
1517         then
1518             # Clang also needs -fwrapv
1519             WRAP="-fwrapv"
1520             # bpo-30104: disable strict aliasing to compile correctly dtoa.c,
1521             # see Makefile.pre.in for more information
1522             CFLAGS_ALIASING="-fno-strict-aliasing"
1523         fi
1524 
1525 	case $ac_cv_prog_cc_g in
1526 	yes)
1527 	    if test "$Py_DEBUG" = 'true' ; then
1528 		# Optimization messes up debuggers, so turn it off for
1529 		# debug builds.
1530                 if "$CC" -v --help 2>/dev/null |grep -- -Og > /dev/null; then
1531                     OPT="-g -Og -Wall"
1532                 else
1533                     OPT="-g -O0 -Wall"
1534                 fi
1535 	    else
1536 		OPT="-g $WRAP -O3 -Wall"
1537 	    fi
1538 	    ;;
1539 	*)
1540 	    OPT="-O3 -Wall"
1541 	    ;;
1542 	esac
1543 
1544 	case $ac_sys_system in
1545 	    SCO_SV*) OPT="$OPT -m486 -DSCO5"
1546 	    ;;
1547         esac
1548 	;;
1549 
1550     *)
1551 	OPT="-O"
1552 	;;
1553     esac
1554 fi
1555 
1556 AC_SUBST(BASECFLAGS)
1557 AC_SUBST(CFLAGS_NODIST)
1558 AC_SUBST(LDFLAGS_NODIST)
1559 
1560 # The -arch flags for universal builds on OSX
1561 UNIVERSAL_ARCH_FLAGS=
1562 AC_SUBST(UNIVERSAL_ARCH_FLAGS)
1563 
1564 # tweak BASECFLAGS based on compiler and platform
1565 case $GCC in
1566 yes)
1567     CFLAGS_NODIST="$CFLAGS_NODIST -std=c99"
1568 
1569     AC_MSG_CHECKING(for -Wextra)
1570      ac_save_cc="$CC"
1571      CC="$CC -Wextra -Werror"
1572      AC_CACHE_VAL(ac_cv_extra_warnings,
1573        AC_COMPILE_IFELSE(
1574          [
1575            AC_LANG_PROGRAM([[]], [[]])
1576          ],[
1577            ac_cv_extra_warnings=yes
1578          ],[
1579            ac_cv_extra_warnings=no
1580          ]))
1581      CC="$ac_save_cc"
1582     AC_MSG_RESULT($ac_cv_extra_warnings)
1583 
1584     if test $ac_cv_extra_warnings = yes
1585     then
1586       CFLAGS_NODIST="$CFLAGS_NODIST -Wextra"
1587     fi
1588 
1589     # Python doesn't violate C99 aliasing rules, but older versions of
1590     # GCC produce warnings for legal Python code.  Enable
1591     # -fno-strict-aliasing on versions of GCC that support but produce
1592     # warnings.  See Issue3326
1593     AC_MSG_CHECKING(whether $CC accepts and needs -fno-strict-aliasing)
1594      ac_save_cc="$CC"
1595      CC="$CC -fno-strict-aliasing"
1596      save_CFLAGS="$CFLAGS"
1597      AC_CACHE_VAL(ac_cv_no_strict_aliasing,
1598        AC_COMPILE_IFELSE(
1599          [
1600 	   AC_LANG_PROGRAM([[]], [[]])
1601 	 ],[
1602 	   CC="$ac_save_cc -fstrict-aliasing"
1603            CFLAGS="$CFLAGS -Werror -Wstrict-aliasing"
1604            AC_COMPILE_IFELSE(
1605 	     [
1606 	       AC_LANG_PROGRAM([[void f(int **x) {}]],
1607 	         [[double *x; f((int **) &x);]])
1608 	     ],[
1609 	       ac_cv_no_strict_aliasing=no
1610 	     ],[
1611                ac_cv_no_strict_aliasing=yes
1612 	     ])
1613 	 ],[
1614 	   ac_cv_no_strict_aliasing=no
1615 	 ]))
1616      CFLAGS="$save_CFLAGS"
1617      CC="$ac_save_cc"
1618     AC_MSG_RESULT($ac_cv_no_strict_aliasing)
1619     if test $ac_cv_no_strict_aliasing = yes
1620     then
1621       BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
1622     fi
1623 
1624     # ICC doesn't recognize the option, but only emits a warning
1625     ## XXX does it emit an unused result warning and can it be disabled?
1626     case "$CC" in
1627     *icc*)
1628     ac_cv_disable_unused_result_warning=no
1629     ;;
1630     *)
1631     AC_MSG_CHECKING(if we can turn off $CC unused result warning)
1632      ac_save_cc="$CC"
1633      CC="$CC -Wunused-result -Werror"
1634      save_CFLAGS="$CFLAGS"
1635      AC_CACHE_VAL(ac_cv_disable_unused_result_warning,
1636        AC_COMPILE_IFELSE(
1637          [
1638 	   AC_LANG_PROGRAM([[]], [[]])
1639 	 ],[
1640            ac_cv_disable_unused_result_warning=yes
1641 	 ],[
1642            ac_cv_disable_unused_result_warning=no
1643 	 ]))
1644      CFLAGS="$save_CFLAGS"
1645      CC="$ac_save_cc"
1646     AC_MSG_RESULT($ac_cv_disable_unused_result_warning)
1647     ;;
1648     esac
1649 
1650     if test $ac_cv_disable_unused_result_warning = yes
1651     then
1652       BASECFLAGS="$BASECFLAGS -Wno-unused-result"
1653       CFLAGS_NODIST="$CFLAGS_NODIST -Wno-unused-result"
1654     fi
1655 
1656     AC_MSG_CHECKING(if we can turn off $CC unused parameter warning)
1657      ac_save_cc="$CC"
1658      CC="$CC -Wunused-parameter -Werror"
1659      AC_CACHE_VAL(ac_cv_disable_unused_parameter_warning,
1660        AC_COMPILE_IFELSE(
1661          [
1662            AC_LANG_PROGRAM([[]], [[]])
1663          ],[
1664            ac_cv_disable_unused_parameter_warning=yes
1665          ],[
1666            ac_cv_disable_unused_parameter_warning=no
1667          ]))
1668      CC="$ac_save_cc"
1669     AC_MSG_RESULT($ac_cv_disable_unused_parameter_warning)
1670 
1671     if test $ac_cv_disable_unused_parameter_warning = yes
1672     then
1673       CFLAGS_NODIST="$CFLAGS_NODIST -Wno-unused-parameter"
1674     fi
1675 
1676     AC_MSG_CHECKING(if we can turn off $CC missing field initializers warning)
1677      ac_save_cc="$CC"
1678      CC="$CC -Wmissing-field-initializers -Werror"
1679      AC_CACHE_VAL(ac_cv_disable_missing_field_initializers,
1680        AC_COMPILE_IFELSE(
1681          [
1682            AC_LANG_PROGRAM([[]], [[]])
1683          ],[
1684            ac_cv_disable_missing_field_initializers=yes
1685          ],[
1686            ac_cv_disable_missing_field_initializers=no
1687          ]))
1688      CC="$ac_save_cc"
1689     AC_MSG_RESULT($ac_cv_disable_missing_field_initializers)
1690 
1691     if test $ac_cv_disable_missing_field_initializers = yes
1692     then
1693       CFLAGS_NODIST="$CFLAGS_NODIST -Wno-missing-field-initializers"
1694     fi
1695 
1696     AC_MSG_CHECKING(if we can turn off $CC invalid function cast warning)
1697      ac_save_cc="$CC"
1698      CC="$CC -Wcast-function-type -Werror"
1699      AC_CACHE_VAL(ac_cv_disable_cast_function_type,
1700        AC_COMPILE_IFELSE(
1701          [
1702            AC_LANG_PROGRAM([[]], [[]])
1703          ],[
1704            ac_cv_disable_cast_function_type=yes
1705          ],[
1706            ac_cv_disable_cast_function_type=no
1707          ]))
1708      CC="$ac_save_cc"
1709     AC_MSG_RESULT($ac_cv_disable_cast_function_type)
1710 
1711     if test $ac_cv_disable_cast_function_type = yes
1712     then
1713       CFLAGS_NODIST="$CFLAGS_NODIST -Wno-cast-function-type"
1714     fi
1715 
1716     AC_MSG_CHECKING(if we can turn on $CC mixed sign comparison warning)
1717      ac_save_cc="$CC"
1718      CC="$CC -Wsign-compare"
1719      save_CFLAGS="$CFLAGS"
1720      AC_CACHE_VAL(ac_cv_enable_sign_compare_warning,
1721        AC_COMPILE_IFELSE(
1722          [
1723 	   AC_LANG_PROGRAM([[]], [[]])
1724 	 ],[
1725            ac_cv_enable_sign_compare_warning=yes
1726 	 ],[
1727            ac_cv_enable_sign_compare_warning=no
1728 	 ]))
1729      CFLAGS="$save_CFLAGS"
1730      CC="$ac_save_cc"
1731     AC_MSG_RESULT($ac_cv_enable_sign_compare_warning)
1732 
1733     if test $ac_cv_enable_sign_compare_warning = yes
1734     then
1735       BASECFLAGS="$BASECFLAGS -Wsign-compare"
1736     fi
1737 
1738     AC_MSG_CHECKING(if we can turn on $CC unreachable code warning)
1739      ac_save_cc="$CC"
1740      CC="$CC -Wunreachable-code"
1741      save_CFLAGS="$CFLAGS"
1742      AC_CACHE_VAL(ac_cv_enable_unreachable_code_warning,
1743        AC_COMPILE_IFELSE(
1744          [
1745 	   AC_LANG_PROGRAM([[]], [[]])
1746 	 ],[
1747            ac_cv_enable_unreachable_code_warning=yes
1748 	 ],[
1749            ac_cv_enable_unreachable_code_warning=no
1750 	 ]))
1751      CFLAGS="$save_CFLAGS"
1752      CC="$ac_save_cc"
1753 
1754     # Don't enable unreachable code warning in debug mode, since it usually
1755     # results in non-standard code paths.
1756     # Issue #24324: Unfortunately, the unreachable code warning does not work
1757     # correctly on gcc and has been silently removed from the compiler.
1758     # It is supported on clang but on OS X systems gcc may be an alias
1759     # for clang.  Try to determine if the compiler is not really gcc and,
1760     # if so, only then enable the warning.
1761     if test $ac_cv_enable_unreachable_code_warning = yes && \
1762         test "$Py_DEBUG" != "true" && \
1763         test -z "`$CC --version 2>/dev/null | grep 'Free Software Foundation'`"
1764     then
1765       BASECFLAGS="$BASECFLAGS -Wunreachable-code"
1766     else
1767       ac_cv_enable_unreachable_code_warning=no
1768     fi
1769     AC_MSG_RESULT($ac_cv_enable_unreachable_code_warning)
1770 
1771     AC_MSG_CHECKING(if we can turn on $CC strict-prototypes warning)
1772      ac_save_cc="$CC"
1773      CC="$CC -Werror -Wstrict-prototypes"
1774      AC_CACHE_VAL(ac_cv_enable_enable_strict_prototypes_warning,
1775        AC_COMPILE_IFELSE(
1776          [
1777        AC_LANG_PROGRAM([[]], [[]])
1778      ],[
1779        ac_cv_enable_strict_prototypes_warning=yes
1780      ],[
1781        ac_cv_enable_strict_prototypes_warning=no
1782      ]))
1783      CC="$ac_save_cc"
1784     AC_MSG_RESULT($ac_cv_enable_strict_prototypes_warning)
1785 
1786     if test $ac_cv_enable_strict_prototypes_warning = yes
1787     then
1788       CFLAGS_NODIST="$CFLAGS_NODIST -Wstrict-prototypes"
1789     fi
1790 
1791     AC_MSG_CHECKING(if we can make implicit function declaration an error in $CC)
1792      ac_save_cc="$CC"
1793      CC="$CC -Werror=implicit-function-declaration"
1794      AC_CACHE_VAL(ac_cv_enable_implicit_function_declaration_error,
1795        AC_COMPILE_IFELSE(
1796          [
1797 	   AC_LANG_PROGRAM([[]], [[]])
1798 	 ],[
1799            ac_cv_enable_implicit_function_declaration_error=yes
1800 	 ],[
1801            ac_cv_enable_implicit_function_declaration_error=no
1802 	 ]))
1803      CC="$ac_save_cc"
1804     AC_MSG_RESULT($ac_cv_enable_implicit_function_declaration_error)
1805 
1806     if test $ac_cv_enable_implicit_function_declaration_error = yes
1807     then
1808       CFLAGS_NODIST="$CFLAGS_NODIST -Werror=implicit-function-declaration"
1809     fi
1810 
1811     # if using gcc on alpha, use -mieee to get (near) full IEEE 754
1812     # support.  Without this, treatment of subnormals doesn't follow
1813     # the standard.
1814     case $host in
1815          alpha*)
1816                 BASECFLAGS="$BASECFLAGS -mieee"
1817                 ;;
1818     esac
1819 
1820     case $ac_sys_system in
1821 	SCO_SV*)
1822 	    BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
1823 	    ;;
1824 
1825     # is there any other compiler on Darwin besides gcc?
1826     Darwin*)
1827         # -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
1828         # used to be here, but non-Apple gcc doesn't accept them.
1829         if test "${CC}" = gcc
1830         then
1831             AC_MSG_CHECKING(which compiler should be used)
1832             case "${UNIVERSALSDK}" in
1833             */MacOSX10.4u.sdk)
1834                 # Build using 10.4 SDK, force usage of gcc when the
1835                 # compiler is gcc, otherwise the user will get very
1836                 # confusing error messages when building on OSX 10.6
1837                 CC=gcc-4.0
1838                 CPP=cpp-4.0
1839                 ;;
1840             esac
1841             AC_MSG_RESULT($CC)
1842         fi
1843 
1844         if test "${enable_universalsdk}"
1845         then
1846             case "$UNIVERSAL_ARCHS" in
1847             32-bit)
1848                UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386"
1849                LIPO_32BIT_FLAGS=""
1850                ARCH_RUN_32BIT=""
1851                ;;
1852             64-bit)
1853                UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64"
1854                LIPO_32BIT_FLAGS=""
1855                ARCH_RUN_32BIT="true"
1856                ;;
1857             all)
1858                UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64"
1859                LIPO_32BIT_FLAGS="-extract ppc7400 -extract i386"
1860                ARCH_RUN_32BIT="/usr/bin/arch -i386 -ppc"
1861                ;;
1862             intel)
1863                UNIVERSAL_ARCH_FLAGS="-arch i386 -arch x86_64"
1864                LIPO_32BIT_FLAGS="-extract i386"
1865                ARCH_RUN_32BIT="/usr/bin/arch -i386"
1866                ;;
1867             intel-32)
1868                UNIVERSAL_ARCH_FLAGS="-arch i386"
1869                LIPO_32BIT_FLAGS=""
1870                ARCH_RUN_32BIT=""
1871                ;;
1872             intel-64)
1873                UNIVERSAL_ARCH_FLAGS="-arch x86_64"
1874                LIPO_32BIT_FLAGS=""
1875                ARCH_RUN_32BIT="true"
1876                ;;
1877             3-way)
1878                UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch x86_64"
1879                LIPO_32BIT_FLAGS="-extract ppc7400 -extract i386"
1880                ARCH_RUN_32BIT="/usr/bin/arch -i386 -ppc"
1881                ;;
1882             *)
1883                AC_MSG_ERROR([proper usage is --with-universal-arch=32-bit|64-bit|all|intel|3-way])
1884                ;;
1885             esac
1886 
1887             if test "${UNIVERSALSDK}" != "/"
1888             then
1889                 CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
1890                 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1891                 CPPFLAGS="-isysroot ${UNIVERSALSDK} ${CPPFLAGS}"
1892             else
1893                 CFLAGS="${UNIVERSAL_ARCH_FLAGS} ${CFLAGS}"
1894                 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} ${LDFLAGS}"
1895             fi
1896         fi
1897 
1898         # Calculate an appropriate deployment target for this build:
1899         # The deployment target value is used explicitly to enable certain
1900         # features are enabled (such as builtin libedit support for readline)
1901         # through the use of Apple's Availability Macros and is used as a
1902         # component of the string returned by distutils.get_platform().
1903         #
1904         # Use the value from:
1905         # 1. the MACOSX_DEPLOYMENT_TARGET environment variable if specified
1906         # 2. the operating system version of the build machine if >= 10.6
1907         # 3. If running on OS X 10.3 through 10.5, use the legacy tests
1908         #       below to pick either 10.3, 10.4, or 10.5 as the target.
1909         # 4. If we are running on OS X 10.2 or earlier, good luck!
1910 
1911         AC_MSG_CHECKING(which MACOSX_DEPLOYMENT_TARGET to use)
1912         cur_target_major=`sw_vers -productVersion | \
1913                 sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'`
1914         cur_target_minor=`sw_vers -productVersion | \
1915                 sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'`
1916         cur_target="${cur_target_major}.${cur_target_minor}"
1917         if test ${cur_target_major} -eq 10 && \
1918            test ${cur_target_minor} -ge 3 && \
1919            test ${cur_target_minor} -le 5
1920         then
1921             # OS X 10.3 through 10.5
1922             cur_target=10.3
1923             if test ${enable_universalsdk}
1924             then
1925                 case "$UNIVERSAL_ARCHS" in
1926                 all|3-way|intel|64-bit)
1927                     # These configurations were first supported in 10.5
1928                     cur_target='10.5'
1929                     ;;
1930                 esac
1931             else
1932                 if test `/usr/bin/arch` = "i386"
1933                 then
1934                     # 10.4 was the first release to support Intel archs
1935                     cur_target="10.4"
1936                 fi
1937             fi
1938         fi
1939         CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1940 
1941         # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
1942         # environment with a value that is the same as what we'll use
1943         # in the Makefile to ensure that we'll get the same compiler
1944         # environment during configure and build time.
1945         MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
1946         export MACOSX_DEPLOYMENT_TARGET
1947         EXPORT_MACOSX_DEPLOYMENT_TARGET=''
1948         AC_MSG_RESULT($MACOSX_DEPLOYMENT_TARGET)
1949 
1950         # end of Darwin* tests
1951         ;;
1952     esac
1953     ;;
1954 
1955 *)
1956     case $ac_sys_system in
1957     OpenUNIX*|UnixWare*)
1958 	BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
1959 	;;
1960     SCO_SV*)
1961 	BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
1962 	;;
1963     esac
1964     ;;
1965 esac
1966 
1967 # ICC needs -fp-model strict or floats behave badly
1968 case "$CC" in
1969 *icc*)
1970     CFLAGS_NODIST="$CFLAGS_NODIST -fp-model strict"
1971     ;;
1972 esac
1973 
1974 if test "$assertions" = 'true'; then
1975   :
1976 else
1977   OPT="-DNDEBUG $OPT"
1978 fi
1979 
1980 if test "$ac_arch_flags"
1981 then
1982 	BASECFLAGS="$BASECFLAGS $ac_arch_flags"
1983 fi
1984 
1985 # On some compilers, pthreads are available without further options
1986 # (e.g. MacOS X). On some of these systems, the compiler will not
1987 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
1988 # So we have to see first whether pthreads are available without
1989 # options before we can check whether -Kpthread improves anything.
1990 AC_MSG_CHECKING(whether pthreads are available without options)
1991 AC_CACHE_VAL(ac_cv_pthread_is_default,
1992 [AC_RUN_IFELSE([AC_LANG_SOURCE([[
1993 #include <stdio.h>
1994 #include <pthread.h>
1995 
1996 void* routine(void* p){return NULL;}
1997 
1998 int main(){
1999   pthread_t p;
2000   if(pthread_create(&p,NULL,routine,NULL)!=0)
2001     return 1;
2002   (void)pthread_detach(p);
2003   return 0;
2004 }
2005 ]])],[
2006   ac_cv_pthread_is_default=yes
2007   ac_cv_kthread=no
2008   ac_cv_pthread=no
2009 ],[ac_cv_pthread_is_default=no],[ac_cv_pthread_is_default=no])
2010 ])
2011 AC_MSG_RESULT($ac_cv_pthread_is_default)
2012 
2013 
2014 if test $ac_cv_pthread_is_default = yes
2015 then
2016   ac_cv_kpthread=no
2017 else
2018 # -Kpthread, if available, provides the right #defines
2019 # and linker options to make pthread_create available
2020 # Some compilers won't report that they do not support -Kpthread,
2021 # so we need to run a program to see whether it really made the
2022 # function available.
2023 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
2024 AC_CACHE_VAL(ac_cv_kpthread,
2025 [ac_save_cc="$CC"
2026 CC="$CC -Kpthread"
2027 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2028 #include <stdio.h>
2029 #include <pthread.h>
2030 
2031 void* routine(void* p){return NULL;}
2032 
2033 int main(){
2034   pthread_t p;
2035   if(pthread_create(&p,NULL,routine,NULL)!=0)
2036     return 1;
2037   (void)pthread_detach(p);
2038   return 0;
2039 }
2040 ]])],[ac_cv_kpthread=yes],[ac_cv_kpthread=no],[ac_cv_kpthread=no])
2041 CC="$ac_save_cc"])
2042 AC_MSG_RESULT($ac_cv_kpthread)
2043 fi
2044 
2045 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
2046 then
2047 # -Kthread, if available, provides the right #defines
2048 # and linker options to make pthread_create available
2049 # Some compilers won't report that they do not support -Kthread,
2050 # so we need to run a program to see whether it really made the
2051 # function available.
2052 AC_MSG_CHECKING(whether $CC accepts -Kthread)
2053 AC_CACHE_VAL(ac_cv_kthread,
2054 [ac_save_cc="$CC"
2055 CC="$CC -Kthread"
2056 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2057 #include <stdio.h>
2058 #include <pthread.h>
2059 
2060 void* routine(void* p){return NULL;}
2061 
2062 int main(){
2063   pthread_t p;
2064   if(pthread_create(&p,NULL,routine,NULL)!=0)
2065     return 1;
2066   (void)pthread_detach(p);
2067   return 0;
2068 }
2069 ]])],[ac_cv_kthread=yes],[ac_cv_kthread=no],[ac_cv_kthread=no])
2070 CC="$ac_save_cc"])
2071 AC_MSG_RESULT($ac_cv_kthread)
2072 fi
2073 
2074 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
2075 then
2076 # -pthread, if available, provides the right #defines
2077 # and linker options to make pthread_create available
2078 # Some compilers won't report that they do not support -pthread,
2079 # so we need to run a program to see whether it really made the
2080 # function available.
2081 AC_MSG_CHECKING(whether $CC accepts -pthread)
2082 AC_CACHE_VAL(ac_cv_pthread,
2083 [ac_save_cc="$CC"
2084 CC="$CC -pthread"
2085 AC_RUN_IFELSE([AC_LANG_SOURCE([[
2086 #include <stdio.h>
2087 #include <pthread.h>
2088 
2089 void* routine(void* p){return NULL;}
2090 
2091 int main(){
2092   pthread_t p;
2093   if(pthread_create(&p,NULL,routine,NULL)!=0)
2094     return 1;
2095   (void)pthread_detach(p);
2096   return 0;
2097 }
2098 ]])],[ac_cv_pthread=yes],[ac_cv_pthread=no],[ac_cv_pthread=no])
2099 CC="$ac_save_cc"])
2100 AC_MSG_RESULT($ac_cv_pthread)
2101 fi
2102 
2103 # If we have set a CC compiler flag for thread support then
2104 # check if it works for CXX, too.
2105 ac_cv_cxx_thread=no
2106 if test ! -z "$CXX"
2107 then
2108 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
2109 ac_save_cxx="$CXX"
2110 
2111 if test "$ac_cv_kpthread" = "yes"
2112 then
2113   CXX="$CXX -Kpthread"
2114   ac_cv_cxx_thread=yes
2115 elif test "$ac_cv_kthread" = "yes"
2116 then
2117   CXX="$CXX -Kthread"
2118   ac_cv_cxx_thread=yes
2119 elif test "$ac_cv_pthread" = "yes"
2120 then
2121   CXX="$CXX -pthread"
2122   ac_cv_cxx_thread=yes
2123 fi
2124 
2125 if test $ac_cv_cxx_thread = yes
2126 then
2127   echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
2128   $CXX -c conftest.$ac_ext 2>&5
2129   if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
2130      && test -s conftest$ac_exeext && ./conftest$ac_exeext
2131   then
2132     ac_cv_cxx_thread=yes
2133   else
2134     ac_cv_cxx_thread=no
2135   fi
2136   rm -fr conftest*
2137 fi
2138 AC_MSG_RESULT($ac_cv_cxx_thread)
2139 fi
2140 CXX="$ac_save_cxx"
2141 
2142 dnl # check for ANSI or K&R ("traditional") preprocessor
2143 dnl AC_MSG_CHECKING(for C preprocessor type)
2144 dnl AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
2145 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
2146 dnl int foo;
2147 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
2148 dnl ]], [[;]])],[cpp_type=ansi],[AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional])
2149 dnl AC_MSG_RESULT($cpp_type)
2150 
2151 # checks for header files
2152 AC_HEADER_STDC
2153 AC_CHECK_HEADERS(asm/types.h crypt.h conio.h direct.h dlfcn.h errno.h \
2154 fcntl.h grp.h \
2155 ieeefp.h io.h langinfo.h libintl.h process.h pthread.h \
2156 sched.h shadow.h signal.h stropts.h termios.h \
2157 unistd.h utime.h \
2158 poll.h sys/devpoll.h sys/epoll.h sys/poll.h \
2159 sys/audioio.h sys/xattr.h sys/bsdtty.h sys/event.h sys/file.h sys/ioctl.h \
2160 sys/kern_control.h sys/loadavg.h sys/lock.h sys/mkdev.h sys/modem.h \
2161 sys/param.h sys/random.h sys/select.h sys/sendfile.h sys/socket.h sys/statvfs.h \
2162 sys/stat.h sys/syscall.h sys/sys_domain.h sys/termio.h sys/time.h \
2163 sys/times.h sys/types.h sys/uio.h sys/un.h sys/utsname.h sys/wait.h pty.h \
2164 libutil.h sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
2165 linux/tipc.h linux/random.h spawn.h util.h alloca.h endian.h \
2166 sys/endian.h sys/sysmacros.h)
2167 AC_HEADER_DIRENT
2168 AC_HEADER_MAJOR
2169 
2170 # bluetooth/bluetooth.h has been known to not compile with -std=c99.
2171 # http://permalink.gmane.org/gmane.linux.bluez.kernel/22294
2172 SAVE_CFLAGS=$CFLAGS
2173 CFLAGS="-std=c99 $CFLAGS"
2174 AC_CHECK_HEADERS(bluetooth/bluetooth.h)
2175 CFLAGS=$SAVE_CFLAGS
2176 
2177 # On Darwin (OS X) net/if.h requires sys/socket.h to be imported first.
2178 AC_CHECK_HEADERS([net/if.h], [], [],
2179 [#include <stdio.h>
2180 #ifdef STDC_HEADERS
2181 # include <stdlib.h>
2182 # include <stddef.h>
2183 #else
2184 # ifdef HAVE_STDLIB_H
2185 #  include <stdlib.h>
2186 # endif
2187 #endif
2188 #ifdef HAVE_SYS_SOCKET_H
2189 # include <sys/socket.h>
2190 #endif
2191 ])
2192 
2193 # On Linux, netlink.h requires asm/types.h
2194 AC_CHECK_HEADERS(linux/netlink.h,,,[
2195 #ifdef HAVE_ASM_TYPES_H
2196 #include <asm/types.h>
2197 #endif
2198 #ifdef HAVE_SYS_SOCKET_H
2199 #include <sys/socket.h>
2200 #endif
2201 ])
2202 
2203 AC_CHECK_HEADERS(linux/vm_sockets.h,,,[
2204 #ifdef HAVE_SYS_SOCKET_H
2205 #include <sys/socket.h>
2206 #endif
2207 ])
2208 
2209 # On Linux, can.h and can/raw.h require sys/socket.h
2210 AC_CHECK_HEADERS(linux/can.h linux/can/raw.h linux/can/bcm.h,,,[
2211 #ifdef HAVE_SYS_SOCKET_H
2212 #include <sys/socket.h>
2213 #endif
2214 ])
2215 
2216 # checks for typedefs
2217 was_it_defined=no
2218 AC_MSG_CHECKING(for clock_t in time.h)
2219 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
2220     AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
2221 ])
2222 AC_MSG_RESULT($was_it_defined)
2223 
2224 AC_MSG_CHECKING(for makedev)
2225 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2226 #if defined(MAJOR_IN_MKDEV)
2227 #include <sys/mkdev.h>
2228 #elif defined(MAJOR_IN_SYSMACROS)
2229 #include <sys/sysmacros.h>
2230 #else
2231 #include <sys/types.h>
2232 #endif
2233 ]], [[
2234   makedev(0, 0) ]])
2235 ],[ac_cv_has_makedev=yes],[ac_cv_has_makedev=no])
2236 AC_MSG_RESULT($ac_cv_has_makedev)
2237 if test "$ac_cv_has_makedev" = "yes"; then
2238     AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
2239 fi
2240 
2241 # byte swapping
2242 AC_MSG_CHECKING(for le64toh)
2243 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2244 #ifdef HAVE_ENDIAN_H
2245 #include <endian.h>
2246 #elif defined(HAVE_SYS_ENDIAN_H)
2247 #include <sys/endian.h>
2248 #endif
2249 ]], [[
2250    le64toh(1) ]])
2251 ],[ac_cv_has_le64toh=yes],[ac_cv_has_le64toh=no])
2252 AC_MSG_RESULT($ac_cv_has_le64toh)
2253 if test "$ac_cv_has_le64toh" = "yes"; then
2254     AC_DEFINE(HAVE_HTOLE64, 1, [Define this if you have le64toh()])
2255 fi
2256 
2257 use_lfs=yes
2258 # Don't use largefile support for GNU/Hurd
2259 case $ac_sys_system in GNU*)
2260   use_lfs=no
2261 esac
2262 
2263 if test "$use_lfs" = "yes"; then
2264 # Two defines needed to enable largefile support on various platforms
2265 # These may affect some typedefs
2266 case $ac_sys_system/$ac_sys_release in
2267 AIX*)
2268     AC_DEFINE(_LARGE_FILES, 1,
2269     [This must be defined on AIX systems to enable large file support.])
2270     ;;
2271 esac
2272 AC_DEFINE(_LARGEFILE_SOURCE, 1,
2273 [This must be defined on some systems to enable large file support.])
2274 AC_DEFINE(_FILE_OFFSET_BITS, 64,
2275 [This must be set to 64 on some systems to enable large file support.])
2276 fi
2277 
2278 # Add some code to confdefs.h so that the test for off_t works on SCO
2279 cat >> confdefs.h <<\EOF
2280 #if defined(SCO_DS)
2281 #undef _OFF_T
2282 #endif
2283 EOF
2284 
2285 # Type availability checks
2286 AC_TYPE_MODE_T
2287 AC_TYPE_OFF_T
2288 AC_TYPE_PID_T
2289 AC_DEFINE_UNQUOTED([RETSIGTYPE],[void],[assume C89 semantics that RETSIGTYPE is always void])
2290 AC_TYPE_SIZE_T
2291 AC_TYPE_UID_T
2292 
2293 AC_CHECK_TYPE(ssize_t,
2294   AC_DEFINE(HAVE_SSIZE_T, 1, [Define if your compiler provides ssize_t]),,)
2295 AC_CHECK_TYPE(__uint128_t,
2296   AC_DEFINE(HAVE_GCC_UINT128_T, 1, [Define if your compiler provides __uint128_t]),,)
2297 
2298 # Sizes of various common basic types
2299 # ANSI C requires sizeof(char) == 1, so no need to check it
2300 AC_CHECK_SIZEOF(int, 4)
2301 AC_CHECK_SIZEOF(long, 4)
2302 AC_CHECK_SIZEOF(long long, 8)
2303 AC_CHECK_SIZEOF(void *, 4)
2304 AC_CHECK_SIZEOF(short, 2)
2305 AC_CHECK_SIZEOF(float, 4)
2306 AC_CHECK_SIZEOF(double, 8)
2307 AC_CHECK_SIZEOF(fpos_t, 4)
2308 AC_CHECK_SIZEOF(size_t, 4)
2309 AC_CHECK_SIZEOF(pid_t, 4)
2310 AC_CHECK_SIZEOF(uintptr_t)
2311 
2312 AC_MSG_CHECKING(for long double support)
2313 have_long_double=no
2314 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[long double x; x = (long double)0;]])],[
2315   AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define this if you have the type long double.])
2316   have_long_double=yes
2317 ],[])
2318 AC_MSG_RESULT($have_long_double)
2319 if test "$have_long_double" = yes ; then
2320 AC_CHECK_SIZEOF(long double, 16)
2321 fi
2322 
2323 AC_CHECK_SIZEOF(_Bool, 1)
2324 
2325 AC_CHECK_SIZEOF(off_t, [], [
2326 #ifdef HAVE_SYS_TYPES_H
2327 #include <sys/types.h>
2328 #endif
2329 ])
2330 
2331 AC_MSG_CHECKING(whether to enable large file support)
2332 if test "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
2333 	"$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
2334   AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
2335   [Defined to enable large file support when an off_t is bigger than a long
2336    and long long is available and at least as big as an off_t. You may need
2337    to add some flags for configuration and compilation to enable this mode.
2338    (For Solaris and Linux, the necessary defines are already defined.)])
2339   AC_MSG_RESULT(yes)
2340 else
2341   AC_MSG_RESULT(no)
2342 fi
2343 
2344 AC_CHECK_SIZEOF(time_t, [], [
2345 #ifdef HAVE_SYS_TYPES_H
2346 #include <sys/types.h>
2347 #endif
2348 #ifdef HAVE_TIME_H
2349 #include <time.h>
2350 #endif
2351 ])
2352 
2353 # if have pthread_t then define SIZEOF_PTHREAD_T
2354 ac_save_cc="$CC"
2355 if test "$ac_cv_kpthread" = "yes"
2356 then CC="$CC -Kpthread"
2357 elif test "$ac_cv_kthread" = "yes"
2358 then CC="$CC -Kthread"
2359 elif test "$ac_cv_pthread" = "yes"
2360 then CC="$CC -pthread"
2361 fi
2362 
2363 AC_MSG_CHECKING(for pthread_t)
2364 have_pthread_t=no
2365 AC_COMPILE_IFELSE([
2366   AC_LANG_PROGRAM([[#include <pthread.h>]], [[pthread_t x; x = *(pthread_t*)0;]])
2367 ],[have_pthread_t=yes],[])
2368 AC_MSG_RESULT($have_pthread_t)
2369 if test "$have_pthread_t" = yes ; then
2370   AC_CHECK_SIZEOF(pthread_t, [], [
2371 #ifdef HAVE_PTHREAD_H
2372 #include <pthread.h>
2373 #endif
2374   ])
2375 fi
2376 
2377 # Issue #25658: POSIX hasn't defined that pthread_key_t is compatible with int.
2378 # This checking will be unnecessary after removing deprecated TLS API.
2379 AC_CHECK_SIZEOF(pthread_key_t, [], [[#include <pthread.h>]])
2380 AC_MSG_CHECKING(whether pthread_key_t is compatible with int)
2381 if test "$ac_cv_sizeof_pthread_key_t" -eq "$ac_cv_sizeof_int" ; then
2382   AC_COMPILE_IFELSE(
2383     [AC_LANG_PROGRAM([[#include <pthread.h>]], [[pthread_key_t k; k * 1;]])],
2384     [ac_pthread_key_t_is_arithmetic_type=yes],
2385     [ac_pthread_key_t_is_arithmetic_type=no]
2386   )
2387   AC_MSG_RESULT($ac_pthread_key_t_is_arithmetic_type)
2388   if test "$ac_pthread_key_t_is_arithmetic_type" = yes ; then
2389     AC_DEFINE(PTHREAD_KEY_T_IS_COMPATIBLE_WITH_INT, 1,
2390               [Define if pthread_key_t is compatible with int.])
2391   fi
2392 else
2393   AC_MSG_RESULT(no)
2394 fi
2395 CC="$ac_save_cc"
2396 
2397 AC_SUBST(OTHER_LIBTOOL_OPT)
2398 case $ac_sys_system/$ac_sys_release in
2399   Darwin/@<:@01567@:>@\..*)
2400     OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
2401     ;;
2402   Darwin/*)
2403     OTHER_LIBTOOL_OPT=""
2404     ;;
2405 esac
2406 
2407 
2408 AC_SUBST(LIBTOOL_CRUFT)
2409 case $ac_sys_system/$ac_sys_release in
2410   Darwin/@<:@01567@:>@\..*)
2411     LIBTOOL_CRUFT="-framework System -lcc_dynamic"
2412     if test "${enable_universalsdk}"; then
2413 	    :
2414     else
2415         LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `/usr/bin/arch`"
2416     fi
2417     LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2418     LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
2419   Darwin/*)
2420     gcc_version=`gcc -dumpversion`
2421     if test ${gcc_version} '<' 4.0
2422         then
2423             LIBTOOL_CRUFT="-lcc_dynamic"
2424         else
2425             LIBTOOL_CRUFT=""
2426     fi
2427     AC_RUN_IFELSE([AC_LANG_SOURCE([[
2428     #include <unistd.h>
2429     int main(int argc, char*argv[])
2430     {
2431       if (sizeof(long) == 4) {
2432     	  return 0;
2433       } else {
2434       	  return 1;
2435       }
2436     }
2437     ]])],[ac_osx_32bit=yes],[ac_osx_32bit=no],[ac_osx_32bit=yes])
2438 
2439     if test "${ac_osx_32bit}" = "yes"; then
2440     	case `/usr/bin/arch` in
2441     	i386)
2442     		MACOSX_DEFAULT_ARCH="i386"
2443     		;;
2444     	ppc)
2445     		MACOSX_DEFAULT_ARCH="ppc"
2446     		;;
2447     	*)
2448     		AC_MSG_ERROR([Unexpected output of 'arch' on OSX])
2449     		;;
2450     	esac
2451     else
2452     	case `/usr/bin/arch` in
2453     	i386)
2454     		MACOSX_DEFAULT_ARCH="x86_64"
2455     		;;
2456     	ppc)
2457     		MACOSX_DEFAULT_ARCH="ppc64"
2458     		;;
2459     	*)
2460     		AC_MSG_ERROR([Unexpected output of 'arch' on OSX])
2461     		;;
2462     	esac
2463 
2464     fi
2465 
2466     LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only ${MACOSX_DEFAULT_ARCH}"
2467     LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2468     LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
2469 esac
2470 AC_MSG_CHECKING(for --enable-framework)
2471 if test "$enable_framework"
2472 then
2473 	BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
2474 	# -F. is needed to allow linking to the framework while
2475 	# in the build location.
2476 	AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
2477          [Define if you want to produce an OpenStep/Rhapsody framework
2478          (shared library plus accessory files).])
2479 	AC_MSG_RESULT(yes)
2480 	if test $enable_shared = "yes"
2481 	then
2482 		AC_MSG_ERROR([Specifying both --enable-shared and --enable-framework is not supported, use only --enable-framework instead])
2483 	fi
2484 else
2485 	AC_MSG_RESULT(no)
2486 fi
2487 
2488 AC_MSG_CHECKING(for dyld)
2489 case $ac_sys_system/$ac_sys_release in
2490   Darwin/*)
2491   	AC_DEFINE(WITH_DYLD, 1,
2492         [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
2493          dynamic linker (dyld) instead of the old-style (NextStep) dynamic
2494          linker (rld). Dyld is necessary to support frameworks.])
2495   	AC_MSG_RESULT(always on for Darwin)
2496   	;;
2497   *)
2498 	AC_MSG_RESULT(no)
2499 	;;
2500 esac
2501 
2502 # Set info about shared libraries.
2503 AC_SUBST(SHLIB_SUFFIX)
2504 AC_SUBST(LDSHARED)
2505 AC_SUBST(LDCXXSHARED)
2506 AC_SUBST(BLDSHARED)
2507 AC_SUBST(CCSHARED)
2508 AC_SUBST(LINKFORSHARED)
2509 
2510 # SHLIB_SUFFIX is the extension of shared libraries `(including the dot!)
2511 # -- usually .so, .sl on HP-UX, .dll on Cygwin
2512 AC_MSG_CHECKING(the extension of shared libraries)
2513 if test -z "$SHLIB_SUFFIX"; then
2514 	case $ac_sys_system in
2515 	hp*|HP*)
2516 		case `uname -m` in
2517 			ia64) SHLIB_SUFFIX=.so;;
2518 	  		*)    SHLIB_SUFFIX=.sl;;
2519 		esac
2520 		;;
2521 	CYGWIN*)   SHLIB_SUFFIX=.dll;;
2522 	*)	   SHLIB_SUFFIX=.so;;
2523 	esac
2524 fi
2525 AC_MSG_RESULT($SHLIB_SUFFIX)
2526 
2527 # LDSHARED is the ld *command* used to create shared library
2528 # -- "cc -G" on SunOS 5.x.
2529 # (Shared libraries in this instance are shared modules to be loaded into
2530 # Python, as opposed to building Python itself as a shared library.)
2531 AC_MSG_CHECKING(LDSHARED)
2532 if test -z "$LDSHARED"
2533 then
2534 	case $ac_sys_system/$ac_sys_release in
2535 	AIX*)
2536 		BLDSHARED="Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
2537 		LDSHARED="\$(LIBPL)/ld_so_aix \$(CC) -bI:\$(LIBPL)/python.exp"
2538 		;;
2539 	SunOS/5*)
2540 		if test "$GCC" = "yes" ; then
2541 			LDSHARED='$(CC) -shared'
2542 			LDCXXSHARED='$(CXX) -shared'
2543 		else
2544 			LDSHARED='$(CC) -G'
2545 			LDCXXSHARED='$(CXX) -G'
2546 		fi ;;
2547 	hp*|HP*)
2548 		if test "$GCC" = "yes" ; then
2549 			LDSHARED='$(CC) -shared'
2550 			LDCXXSHARED='$(CXX) -shared'
2551 		else
2552 			LDSHARED='$(CC) -b'
2553 			LDCXXSHARED='$(CXX) -b'
2554 		fi ;;
2555 	Darwin/1.3*)
2556 		LDSHARED='$(CC) -bundle'
2557 		LDCXXSHARED='$(CXX) -bundle'
2558 		if test "$enable_framework" ; then
2559 			# Link against the framework. All externals should be defined.
2560 			BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2561 			LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2562 			LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2563 		else
2564 			# No framework. Ignore undefined symbols, assuming they come from Python
2565 			LDSHARED="$LDSHARED -undefined suppress"
2566 			LDCXXSHARED="$LDCXXSHARED -undefined suppress"
2567 		fi ;;
2568 	Darwin/1.4*|Darwin/5.*|Darwin/6.*)
2569 		LDSHARED='$(CC) -bundle'
2570 		LDCXXSHARED='$(CXX) -bundle'
2571 		if test "$enable_framework" ; then
2572 			# Link against the framework. All externals should be defined.
2573 			BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2574 			LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2575 			LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2576 		else
2577 			# No framework, use the Python app as bundle-loader
2578 			BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
2579 			LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
2580 			LDCXXSHARED="$LDCXXSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
2581 		fi ;;
2582 	Darwin/*)
2583 		# Use -undefined dynamic_lookup whenever possible (10.3 and later).
2584 		# This allows an extension to be used in any Python
2585 
2586 		dep_target_major=`echo ${MACOSX_DEPLOYMENT_TARGET} | \
2587 				sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'`
2588 		dep_target_minor=`echo ${MACOSX_DEPLOYMENT_TARGET} | \
2589 				sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'`
2590 		if test ${dep_target_major} -eq 10 && \
2591 		   test ${dep_target_minor} -le 2
2592 		then
2593 			# building for OS X 10.0 through 10.2
2594 			LDSHARED='$(CC) -bundle'
2595 			LDCXXSHARED='$(CXX) -bundle'
2596 			if test "$enable_framework" ; then
2597 				# Link against the framework. All externals should be defined.
2598 				BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2599 				LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2600 				LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2601 			else
2602 				# No framework, use the Python app as bundle-loader
2603 				BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
2604 				LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
2605 				LDCXXSHARED="$LDCXXSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
2606 			fi
2607 		else
2608 			# building for OS X 10.3 and later
2609 			LDSHARED='$(CC) -bundle -undefined dynamic_lookup'
2610 			LDCXXSHARED='$(CXX) -bundle -undefined dynamic_lookup'
2611 			BLDSHARED="$LDSHARED"
2612 		fi
2613 		;;
2614 	Linux*|GNU*|QNX*)
2615 		LDSHARED='$(CC) -shared'
2616 		LDCXXSHARED='$(CXX) -shared';;
2617 	FreeBSD*)
2618 		if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
2619 		then
2620 			LDSHARED='$(CC) -shared'
2621 			LDCXXSHARED='$(CXX) -shared'
2622 		else
2623 			LDSHARED="ld -Bshareable"
2624 		fi;;
2625 	OpenBSD*)
2626 		if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
2627 		then
2628 				LDSHARED='$(CC) -shared $(CCSHARED)'
2629 				LDCXXSHARED='$(CXX) -shared $(CCSHARED)'
2630 		else
2631 				case `uname -r` in
2632 				[[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
2633 				   LDSHARED="ld -Bshareable ${LDFLAGS}"
2634 				   ;;
2635 				*)
2636 				   LDSHARED='$(CC) -shared $(CCSHARED)'
2637 				   LDCXXSHARED='$(CXX) -shared $(CCSHARED)'
2638 				   ;;
2639 				esac
2640 		fi;;
2641 	NetBSD*|DragonFly*)
2642 		LDSHARED='$(CC) -shared'
2643 		LDCXXSHARED='$(CXX) -shared';;
2644 	OpenUNIX*|UnixWare*)
2645 		if test "$GCC" = "yes" ; then
2646 			LDSHARED='$(CC) -shared'
2647 			LDCXXSHARED='$(CXX) -shared'
2648 		else
2649 			LDSHARED='$(CC) -G'
2650 			LDCXXSHARED='$(CXX) -G'
2651 		fi;;
2652 	SCO_SV*)
2653 		LDSHARED='$(CC) -Wl,-G,-Bexport'
2654 		LDCXXSHARED='$(CXX) -Wl,-G,-Bexport';;
2655 	CYGWIN*)
2656 		LDSHARED="gcc -shared -Wl,--enable-auto-image-base"
2657 		LDCXXSHARED="g++ -shared -Wl,--enable-auto-image-base";;
2658 	*)	LDSHARED="ld";;
2659 	esac
2660 fi
2661 AC_MSG_RESULT($LDSHARED)
2662 LDCXXSHARED=${LDCXXSHARED-$LDSHARED}
2663 BLDSHARED=${BLDSHARED-$LDSHARED}
2664 # CCSHARED are the C *flags* used to create objects to go into a shared
2665 # library (module) -- this is only needed for a few systems
2666 AC_MSG_CHECKING(CCSHARED)
2667 if test -z "$CCSHARED"
2668 then
2669 	case $ac_sys_system/$ac_sys_release in
2670 	SunOS*) if test "$GCC" = yes;
2671 		then CCSHARED="-fPIC";
2672 		elif test `uname -p` = sparc;
2673 		then CCSHARED="-xcode=pic32";
2674 		else CCSHARED="-Kpic";
2675 		fi;;
2676 	hp*|HP*) if test "$GCC" = yes;
2677 		 then CCSHARED="-fPIC";
2678 		 else CCSHARED="+z";
2679 		 fi;;
2680 	Linux-android*) ;;
2681 	Linux*|GNU*) CCSHARED="-fPIC";;
2682 	FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
2683 	OpenUNIX*|UnixWare*)
2684 		if test "$GCC" = "yes"
2685 		then CCSHARED="-fPIC"
2686 		else CCSHARED="-KPIC"
2687 		fi;;
2688 	SCO_SV*)
2689 		if test "$GCC" = "yes"
2690 		then CCSHARED="-fPIC"
2691 		else CCSHARED="-Kpic -belf"
2692 		fi;;
2693 	esac
2694 fi
2695 AC_MSG_RESULT($CCSHARED)
2696 # LINKFORSHARED are the flags passed to the $(CC) command that links
2697 # the python executable -- this is only needed for a few systems
2698 AC_MSG_CHECKING(LINKFORSHARED)
2699 if test -z "$LINKFORSHARED"
2700 then
2701 	case $ac_sys_system/$ac_sys_release in
2702 	AIX*)	LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
2703 	hp*|HP*)
2704 	    LINKFORSHARED="-Wl,-E -Wl,+s";;
2705 #	    LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
2706 	Linux-android*) LINKFORSHARED="-pie -Xlinker -export-dynamic";;
2707 	Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
2708 	# -u libsys_s pulls in all symbols in libsys
2709 	Darwin/*)
2710 		LINKFORSHARED="$extra_undefs -framework CoreFoundation"
2711 
2712 		# Issue #18075: the default maximum stack size (8MBytes) is too
2713 		# small for the default recursion limit. Increase the stack size
2714 		# to ensure that tests don't crash
2715 		LINKFORSHARED="-Wl,-stack_size,1000000 $LINKFORSHARED"
2716 
2717 		if test "$enable_framework"
2718 		then
2719 			LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2720 		fi
2721 		LINKFORSHARED="$LINKFORSHARED";;
2722 	OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
2723 	SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
2724 	ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
2725 	FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
2726 		if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
2727 		then
2728 			LINKFORSHARED="-Wl,--export-dynamic"
2729 		fi;;
2730 	SunOS/5*) case $CC in
2731 		  *gcc*)
2732 		    if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
2733 		    then
2734 			LINKFORSHARED="-Xlinker --export-dynamic"
2735 		    fi;;
2736 		  esac;;
2737 	CYGWIN*)
2738 		if test $enable_shared = "no"
2739 		then
2740 			LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
2741 		fi;;
2742 	QNX*)
2743 		# -Wl,-E causes the symbols to be added to the dynamic
2744 		# symbol table so that they can be found when a module
2745 		# is loaded.  -N 2048K causes the stack size to be set
2746 		# to 2048 kilobytes so that the stack doesn't overflow
2747 		# when running test_compile.py.
2748 		LINKFORSHARED='-Wl,-E -N 2048K';;
2749 	esac
2750 fi
2751 AC_MSG_RESULT($LINKFORSHARED)
2752 
2753 
2754 AC_SUBST(CFLAGSFORSHARED)
2755 AC_MSG_CHECKING(CFLAGSFORSHARED)
2756 if test ! "$LIBRARY" = "$LDLIBRARY"
2757 then
2758 	case $ac_sys_system in
2759 	CYGWIN*)
2760 		# Cygwin needs CCSHARED when building extension DLLs
2761 		# but not when building the interpreter DLL.
2762 		CFLAGSFORSHARED='';;
2763 	*)
2764 		CFLAGSFORSHARED='$(CCSHARED)'
2765 	esac
2766 fi
2767 AC_MSG_RESULT($CFLAGSFORSHARED)
2768 
2769 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
2770 # library (with --enable-shared).
2771 # For platforms on which shared libraries are not allowed to have unresolved
2772 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
2773 # if it is not required, since it creates a dependency of the shared library
2774 # to LIBS. This, in turn, means that applications linking the shared libpython
2775 # don't need to link LIBS explicitly. The default should be only changed
2776 # on systems where this approach causes problems.
2777 AC_SUBST(SHLIBS)
2778 AC_MSG_CHECKING(SHLIBS)
2779 case "$ac_sys_system" in
2780 	*)
2781 		SHLIBS='$(LIBS)';;
2782 esac
2783 AC_MSG_RESULT($SHLIBS)
2784 
2785 
2786 # checks for libraries
2787 AC_CHECK_LIB(sendfile, sendfile)
2788 AC_CHECK_LIB(dl, dlopen)	# Dynamic linking for SunOS/Solaris and SYSV
2789 AC_CHECK_LIB(dld, shl_load)	# Dynamic linking for HP-UX
2790 
2791 # checks for uuid.h location
2792 AC_CHECK_HEADERS([uuid/uuid.h uuid.h])
2793 
2794 AC_MSG_CHECKING(for uuid_generate_time_safe)
2795 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <uuid/uuid.h>]], [[
2796 #ifndef uuid_generate_time_safe
2797 void *x = uuid_generate_time_safe
2798 #endif
2799 ]])],
2800   [AC_DEFINE(HAVE_UUID_GENERATE_TIME_SAFE, 1, Define if uuid_generate_time_safe() exists.)
2801    AC_MSG_RESULT(yes)],
2802   [AC_MSG_RESULT(no)]
2803 )
2804 
2805 # AIX provides support for RFC4122 (uuid) in libc.a starting with AIX 6.1 (anno 2007)
2806 # FreeBSD and OpenBSD provides support as well
2807 AC_MSG_CHECKING(for uuid_create)
2808 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <uuid.h>]], [[
2809 #ifndef uuid_create
2810 void *x = uuid_create
2811 #endif
2812 ]])],
2813   [AC_DEFINE(HAVE_UUID_CREATE, 1, Define if uuid_create() exists.)
2814    AC_MSG_RESULT(yes)],
2815   [AC_MSG_RESULT(no)]
2816 )
2817 
2818 # Little-endian FreeBSD, OpenBSD and NetBSD needs encoding into an octet
2819 # stream in big-endian byte-order
2820 AC_MSG_CHECKING(for uuid_enc_be)
2821 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <uuid.h>]], [[
2822 #ifndef uuid_enc_be
2823 void *x = uuid_enc_be
2824 #endif
2825 ]])],
2826   [AC_DEFINE(HAVE_UUID_ENC_BE, 1, Define if uuid_enc_be() exists.)
2827    AC_MSG_RESULT(yes)],
2828   [AC_MSG_RESULT(no)]
2829 )
2830 
2831 # 'Real Time' functions on Solaris
2832 # posix4 on Solaris 2.6
2833 # pthread (first!) on Linux
2834 AC_SEARCH_LIBS(sem_init, pthread rt posix4)
2835 
2836 # check if we need libintl for locale functions
2837 AC_CHECK_LIB(intl, textdomain,
2838 	[AC_DEFINE(WITH_LIBINTL, 1,
2839 	[Define to 1 if libintl is needed for locale functions.])
2840         LIBS="-lintl $LIBS"])
2841 
2842 # checks for system dependent C++ extensions support
2843 case "$ac_sys_system" in
2844 	AIX*)	AC_MSG_CHECKING(for genuine AIX C++ extensions support)
2845 		AC_LINK_IFELSE([
2846 		  AC_LANG_PROGRAM([[#include <load.h>]],
2847 				  [[loadAndInit("", 0, "")]])
2848 		],[
2849 		  AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
2850                       [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
2851                        and you want support for AIX C++ shared extension modules.])
2852 		  AC_MSG_RESULT(yes)
2853 		],[
2854 		  AC_MSG_RESULT(no)
2855 		]);;
2856 	*) ;;
2857 esac
2858 
2859 # check for systems that require aligned memory access
2860 AC_MSG_CHECKING(aligned memory access is required)
2861 AC_CACHE_VAL(ac_cv_aligned_required,
2862 [AC_RUN_IFELSE([AC_LANG_SOURCE([[
2863 int main()
2864 {
2865     char s[16];
2866     int i, *p1, *p2;
2867     for (i=0; i < 16; i++)
2868         s[i] = i;
2869     p1 = (int*)(s+1);
2870     p2 = (int*)(s+2);
2871     if (*p1 == *p2)
2872         return 1;
2873     return 0;
2874 }]])],
2875 [ac_cv_aligned_required=no],
2876 [ac_cv_aligned_required=yes],
2877 [ac_cv_aligned_required=yes])
2878 ])
2879 AC_MSG_RESULT($ac_cv_aligned_required)
2880 if test "$ac_cv_aligned_required" = yes ; then
2881   AC_DEFINE([HAVE_ALIGNED_REQUIRED], [1],
2882     [Define if aligned memory access is required])
2883 fi
2884 
2885 # str, bytes and memoryview hash algorithm
2886 AH_TEMPLATE(Py_HASH_ALGORITHM,
2887   [Define hash algorithm for str, bytes and memoryview.
2888    SipHash24: 1, FNV: 2, externally defined: 0])
2889 
2890 AC_MSG_CHECKING(for --with-hash-algorithm)
2891 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2892 AC_ARG_WITH(hash_algorithm,
2893             AS_HELP_STRING([--with-hash-algorithm=@<:@fnv|siphash24@:>@],
2894                            [select hash algorithm]),
2895 [
2896 AC_MSG_RESULT($withval)
2897 case "$withval" in
2898     siphash24)
2899         AC_DEFINE(Py_HASH_ALGORITHM, 1)
2900         ;;
2901     fnv)
2902         AC_DEFINE(Py_HASH_ALGORITHM, 2)
2903         ;;
2904     *)
2905         AC_MSG_ERROR([unknown hash algorithm '$withval'])
2906         ;;
2907 esac
2908 ],
2909 [AC_MSG_RESULT(default)])
2910 
2911 AC_MSG_CHECKING(for --with-address-sanitizer)
2912 AC_ARG_WITH(address_sanitizer,
2913             AS_HELP_STRING([--with-address-sanitizer],
2914                            [enable AddressSanitizer (asan)]),
2915 [
2916 AC_MSG_RESULT($withval)
2917 BASECFLAGS="-fsanitize=address -fno-omit-frame-pointer $BASECFLAGS"
2918 LDFLAGS="-fsanitize=address $LDFLAGS"
2919 # ASan works by controlling memory allocation, our own malloc interferes.
2920 with_pymalloc="no"
2921 ],
2922 [AC_MSG_RESULT(no)])
2923 
2924 AC_MSG_CHECKING(for --with-memory-sanitizer)
2925 AC_ARG_WITH(memory_sanitizer,
2926             AS_HELP_STRING([--with-memory-sanitizer],
2927                            [enable MemorySanitizer (msan)]),
2928 [
2929 AC_MSG_RESULT($withval)
2930 BASECFLAGS="-fsanitize=memory -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer $BASECFLAGS"
2931 LDFLAGS="-fsanitize=memory -fsanitize-memory-track-origins=2 $LDFLAGS"
2932 # MSan works by controlling memory allocation, our own malloc interferes.
2933 with_pymalloc="no"
2934 ],
2935 [AC_MSG_RESULT(no)])
2936 
2937 AC_MSG_CHECKING(for --with-undefined-behavior-sanitizer)
2938 AC_ARG_WITH(undefined_behavior_sanitizer,
2939             AS_HELP_STRING([--with-undefined-behavior-sanitizer],
2940                            [enable UndefinedBehaviorSanitizer (ubsan)]),
2941 [
2942 AC_MSG_RESULT($withval)
2943 BASECFLAGS="-fsanitize=undefined $BASECFLAGS"
2944 LDFLAGS="-fsanitize=undefined $LDFLAGS"
2945 ],
2946 [AC_MSG_RESULT(no)])
2947 
2948 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
2949 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
2950 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
2951 
2952 AC_MSG_CHECKING(for --with-libs)
2953 AC_ARG_WITH(libs,
2954             AS_HELP_STRING([--with-libs='lib1 ...'], [link against additional libs]),
2955 [
2956 AC_MSG_RESULT($withval)
2957 LIBS="$withval $LIBS"
2958 ],
2959 [AC_MSG_RESULT(no)])
2960 
2961 PKG_PROG_PKG_CONFIG
2962 
2963 # Check for use of the system expat library
2964 AC_MSG_CHECKING(for --with-system-expat)
2965 AC_ARG_WITH(system_expat,
2966             AS_HELP_STRING([--with-system-expat], [build pyexpat module using an installed expat library]),
2967             [],
2968             [with_system_expat="no"])
2969 
2970 AC_MSG_RESULT($with_system_expat)
2971 
2972 # Check for use of the system libffi library
2973 AC_MSG_CHECKING(for --with-system-ffi)
2974 AC_ARG_WITH(system_ffi,
2975             AS_HELP_STRING([--with-system-ffi], [build _ctypes module using an installed ffi library]),,,)
2976 
2977 if test "$ac_sys_system" = "Darwin"
2978 then
2979     case "$with_system_ffi" in
2980         "")
2981             with_system_ffi="no"
2982             ;;
2983         yes|no)
2984             ;;
2985         *)
2986             AC_MSG_ERROR([--with-system-ffi accepts no arguments])
2987             ;;
2988     esac
2989     AC_MSG_RESULT($with_system_ffi)
2990 else
2991     AC_MSG_RESULT(yes)
2992     if test "$with_system_ffi" != ""
2993     then
2994         AC_MSG_WARN([--with(out)-system-ffi is ignored on this platform])
2995     fi
2996     with_system_ffi="yes"
2997 fi
2998 
2999 if test "$with_system_ffi" = "yes" && test -n "$PKG_CONFIG"; then
3000     LIBFFI_INCLUDEDIR="`"$PKG_CONFIG" libffi --cflags-only-I 2>/dev/null | sed -e 's/^-I//;s/ *$//'`"
3001 else
3002     LIBFFI_INCLUDEDIR=""
3003 fi
3004 AC_SUBST(LIBFFI_INCLUDEDIR)
3005 
3006 # Check for use of the system libmpdec library
3007 AC_MSG_CHECKING(for --with-system-libmpdec)
3008 AC_ARG_WITH(system_libmpdec,
3009             AS_HELP_STRING([--with-system-libmpdec], [build _decimal module using an installed libmpdec library]),
3010             [],
3011             [with_system_libmpdec="no"])
3012 
3013 AC_MSG_RESULT($with_system_libmpdec)
3014 
3015 # Check for support for loadable sqlite extensions
3016 AC_MSG_CHECKING(for --enable-loadable-sqlite-extensions)
3017 AC_ARG_ENABLE(loadable-sqlite-extensions,
3018               AS_HELP_STRING([--enable-loadable-sqlite-extensions], [support loadable extensions in _sqlite module]),
3019               [],
3020               [enable_loadable_sqlite_extensions="no"])
3021 
3022 AC_MSG_RESULT($enable_loadable_sqlite_extensions)
3023 
3024 # Check for --with-tcltk-includes=path and --with-tcltk-libs=path
3025 AC_SUBST(TCLTK_INCLUDES)
3026 AC_SUBST(TCLTK_LIBS)
3027 AC_MSG_CHECKING(for --with-tcltk-includes)
3028 AC_ARG_WITH(tcltk-includes,
3029             AS_HELP_STRING([--with-tcltk-includes='-I...'], [override search for Tcl and Tk include files]),
3030             [],
3031             [with_tcltk_includes="default"])
3032 AC_MSG_RESULT($with_tcltk_includes)
3033 AC_MSG_CHECKING(for --with-tcltk-libs)
3034 AC_ARG_WITH(tcltk-libs,
3035             AS_HELP_STRING([--with-tcltk-libs='-L...'], [override search for Tcl and Tk libs]),
3036             [],
3037             [with_tcltk_libs="default"])
3038 AC_MSG_RESULT($with_tcltk_libs)
3039 if test "x$with_tcltk_includes" = xdefault || test "x$with_tcltk_libs" = xdefault
3040 then
3041   if test "x$with_tcltk_includes" != "x$with_tcltk_libs"
3042   then
3043     AC_MSG_ERROR([use both --with-tcltk-includes='...' and --with-tcltk-libs='...' or neither])
3044   fi
3045   TCLTK_INCLUDES=""
3046   TCLTK_LIBS=""
3047 else
3048   TCLTK_INCLUDES="$with_tcltk_includes"
3049   TCLTK_LIBS="$with_tcltk_libs"
3050 fi
3051 
3052 # Check for --with-dbmliborder
3053 AC_MSG_CHECKING(for --with-dbmliborder)
3054 AC_ARG_WITH(dbmliborder,
3055             AS_HELP_STRING([--with-dbmliborder=db1:db2:...], [order to check db backends for dbm. Valid value is a colon separated string with the backend names `ndbm', `gdbm' and `bdb'.]),
3056 [
3057 if test x$with_dbmliborder = xyes
3058 then
3059 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
3060 else
3061   for db in `echo $with_dbmliborder | sed 's/:/ /g'`; do
3062     if test x$db != xndbm && test x$db != xgdbm && test x$db != xbdb
3063     then
3064       AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
3065     fi
3066   done
3067 fi])
3068 AC_MSG_RESULT($with_dbmliborder)
3069 
3070 AC_SUBST(LDLAST)
3071 
3072 # Templates for things AC_DEFINEd more than once.
3073 # For a single AC_DEFINE, no template is needed.
3074 AH_TEMPLATE(_REENTRANT,
3075   [Define to force use of thread-safe errno, h_errno, and other functions])
3076 
3077 if test "$ac_cv_pthread_is_default" = yes
3078 then
3079     # Defining _REENTRANT on system with POSIX threads should not hurt.
3080     AC_DEFINE(_REENTRANT)
3081     posix_threads=yes
3082 elif test "$ac_cv_kpthread" = "yes"
3083 then
3084     CC="$CC -Kpthread"
3085     if test "$ac_cv_cxx_thread" = "yes"; then
3086         CXX="$CXX -Kpthread"
3087     fi
3088     posix_threads=yes
3089 elif test "$ac_cv_kthread" = "yes"
3090 then
3091     CC="$CC -Kthread"
3092     if test "$ac_cv_cxx_thread" = "yes"; then
3093         CXX="$CXX -Kthread"
3094     fi
3095     posix_threads=yes
3096 elif test "$ac_cv_pthread" = "yes"
3097 then
3098     CC="$CC -pthread"
3099     if test "$ac_cv_cxx_thread" = "yes"; then
3100         CXX="$CXX -pthread"
3101     fi
3102     posix_threads=yes
3103 else
3104     if test ! -z "$withval" -a -d "$withval"
3105     then LDFLAGS="$LDFLAGS -L$withval"
3106     fi
3107 
3108     # According to the POSIX spec, a pthreads implementation must
3109     # define _POSIX_THREADS in unistd.h. Some apparently don't
3110     # (e.g. gnu pth with pthread emulation)
3111     AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
3112     AC_EGREP_CPP(yes,
3113     [
3114 #include <unistd.h>
3115 #ifdef _POSIX_THREADS
3116 yes
3117 #endif
3118     ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
3119     AC_MSG_RESULT($unistd_defines_pthreads)
3120 
3121     AC_DEFINE(_REENTRANT)
3122     # Just looking for pthread_create in libpthread is not enough:
3123     # on HP/UX, pthread.h renames pthread_create to a different symbol name.
3124     # So we really have to include pthread.h, and then link.
3125     _libs=$LIBS
3126     LIBS="$LIBS -lpthread"
3127     AC_MSG_CHECKING([for pthread_create in -lpthread])
3128     AC_LINK_IFELSE([AC_LANG_PROGRAM([[
3129 #include <stdio.h>
3130 #include <pthread.h>
3131 
3132 void * start_routine (void *arg) { exit (0); }]], [[
3133 pthread_create (NULL, NULL, start_routine, NULL)]])],[
3134     AC_MSG_RESULT(yes)
3135     posix_threads=yes
3136     ],[
3137     LIBS=$_libs
3138     AC_CHECK_FUNC(pthread_detach, [
3139     posix_threads=yes
3140     ],[
3141     AC_CHECK_LIB(pthreads, pthread_create, [
3142     posix_threads=yes
3143     LIBS="$LIBS -lpthreads"
3144     ], [
3145     AC_CHECK_LIB(c_r, pthread_create, [
3146     posix_threads=yes
3147     LIBS="$LIBS -lc_r"
3148     ], [
3149     AC_CHECK_LIB(pthread, __pthread_create_system, [
3150     posix_threads=yes
3151     LIBS="$LIBS -lpthread"
3152     ], [
3153     AC_CHECK_LIB(cma, pthread_create, [
3154     posix_threads=yes
3155     LIBS="$LIBS -lcma"
3156     ],[
3157     AC_MSG_ERROR([could not find pthreads on your system])
3158     ])
3159     ])])])])])
3160 
3161     AC_CHECK_LIB(mpc, usconfig, [
3162     LIBS="$LIBS -lmpc"
3163     ])
3164 
3165 fi
3166 
3167 if test "$posix_threads" = "yes"; then
3168       if test "$unistd_defines_pthreads" = "no"; then
3169          AC_DEFINE(_POSIX_THREADS, 1,
3170          [Define if you have POSIX threads,
3171           and your system does not define that.])
3172       fi
3173 
3174       # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
3175       case  $ac_sys_system/$ac_sys_release in
3176       SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
3177                        [Defined for Solaris 2.6 bug in pthread header.])
3178 		       ;;
3179       SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
3180 		       [Define if the Posix semaphores do not work on your system])
3181 		       ;;
3182       AIX/*) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
3183 		       [Define if the Posix semaphores do not work on your system])
3184 		       ;;
3185       esac
3186 
3187       AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
3188       AC_CACHE_VAL(ac_cv_pthread_system_supported,
3189       [AC_RUN_IFELSE([AC_LANG_SOURCE([[
3190       #include <stdio.h>
3191       #include <pthread.h>
3192       void *foo(void *parm) {
3193         return NULL;
3194       }
3195       main() {
3196         pthread_attr_t attr;
3197         pthread_t id;
3198         if (pthread_attr_init(&attr)) exit(-1);
3199         if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
3200         if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
3201         exit(0);
3202       }]])],
3203       [ac_cv_pthread_system_supported=yes],
3204       [ac_cv_pthread_system_supported=no],
3205       [ac_cv_pthread_system_supported=no])
3206       ])
3207       AC_MSG_RESULT($ac_cv_pthread_system_supported)
3208       if test "$ac_cv_pthread_system_supported" = "yes"; then
3209         AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
3210       fi
3211       AC_CHECK_FUNCS(pthread_sigmask,
3212         [case $ac_sys_system in
3213         CYGWIN*)
3214           AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
3215             [Define if pthread_sigmask() does not work on your system.])
3216             ;;
3217         esac])
3218       AC_CHECK_FUNCS(pthread_getcpuclockid)
3219 fi
3220 
3221 
3222 # Check for enable-ipv6
3223 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
3224 AC_MSG_CHECKING([if --enable-ipv6 is specified])
3225 AC_ARG_ENABLE(ipv6,
3226 [  --enable-ipv6           Enable ipv6 (with ipv4) support
3227   --disable-ipv6          Disable ipv6 support],
3228 [ case "$enableval" in
3229   no)
3230        AC_MSG_RESULT(no)
3231        ipv6=no
3232        ;;
3233   *)   AC_MSG_RESULT(yes)
3234        AC_DEFINE(ENABLE_IPV6)
3235        ipv6=yes
3236        ;;
3237   esac ],
3238 
3239 [
3240 dnl the check does not work on cross compilation case...
3241   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ /* AF_INET6 available check */
3242 #include <sys/types.h>
3243 #include <sys/socket.h>]],
3244 [[int domain = AF_INET6;]])],[
3245   AC_MSG_RESULT(yes)
3246   ipv6=yes
3247 ],[
3248   AC_MSG_RESULT(no)
3249   ipv6=no
3250 ])
3251 
3252 if test "$ipv6" = "yes"; then
3253 	AC_MSG_CHECKING(if RFC2553 API is available)
3254 	AC_COMPILE_IFELSE([
3255 	  AC_LANG_PROGRAM([[#include <sys/types.h>
3256 #include <netinet/in.h>]],
3257 			  [[struct sockaddr_in6 x;
3258 			    x.sin6_scope_id;]])
3259 	],[
3260 	  AC_MSG_RESULT(yes)
3261 	  ipv6=yes
3262 	],[
3263 	  AC_MSG_RESULT(no, IPv6 disabled)
3264 	  ipv6=no
3265 	])
3266 fi
3267 
3268 if test "$ipv6" = "yes"; then
3269 	AC_DEFINE(ENABLE_IPV6)
3270 fi
3271 ])
3272 
3273 ipv6type=unknown
3274 ipv6lib=none
3275 ipv6trylibc=no
3276 
3277 if test "$ipv6" = "yes"; then
3278 	AC_MSG_CHECKING([ipv6 stack type])
3279 	for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
3280 	do
3281 		case $i in
3282 		inria)
3283 			dnl http://www.kame.net/
3284 			AC_EGREP_CPP(yes, [
3285 #include <netinet/in.h>
3286 #ifdef IPV6_INRIA_VERSION
3287 yes
3288 #endif],
3289 				[ipv6type=$i])
3290 			;;
3291 		kame)
3292 			dnl http://www.kame.net/
3293 			AC_EGREP_CPP(yes, [
3294 #include <netinet/in.h>
3295 #ifdef __KAME__
3296 yes
3297 #endif],
3298 				[ipv6type=$i;
3299 				ipv6lib=inet6
3300 				ipv6libdir=/usr/local/v6/lib
3301 				ipv6trylibc=yes])
3302 			;;
3303 		linux-glibc)
3304 			dnl http://www.v6.linux.or.jp/
3305 			AC_EGREP_CPP(yes, [
3306 #include <features.h>
3307 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
3308 yes
3309 #endif],
3310 				[ipv6type=$i;
3311 				ipv6trylibc=yes])
3312 			;;
3313 		linux-inet6)
3314 			dnl http://www.v6.linux.or.jp/
3315 			if test -d /usr/inet6; then
3316 				ipv6type=$i
3317 				ipv6lib=inet6
3318 				ipv6libdir=/usr/inet6/lib
3319 				BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
3320 			fi
3321 			;;
3322 		solaris)
3323 			if test -f /etc/netconfig; then
3324                           if $GREP -q tcp6 /etc/netconfig; then
3325 				ipv6type=$i
3326 				ipv6trylibc=yes
3327                           fi
3328                         fi
3329 			;;
3330 		toshiba)
3331 			AC_EGREP_CPP(yes, [
3332 #include <sys/param.h>
3333 #ifdef _TOSHIBA_INET6
3334 yes
3335 #endif],
3336 				[ipv6type=$i;
3337 				ipv6lib=inet6;
3338 				ipv6libdir=/usr/local/v6/lib])
3339 			;;
3340 		v6d)
3341 			AC_EGREP_CPP(yes, [
3342 #include </usr/local/v6/include/sys/v6config.h>
3343 #ifdef __V6D__
3344 yes
3345 #endif],
3346 				[ipv6type=$i;
3347 				ipv6lib=v6;
3348 				ipv6libdir=/usr/local/v6/lib;
3349 				BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
3350 			;;
3351 		zeta)
3352 			AC_EGREP_CPP(yes, [
3353 #include <sys/param.h>
3354 #ifdef _ZETA_MINAMI_INET6
3355 yes
3356 #endif],
3357 				[ipv6type=$i;
3358 				ipv6lib=inet6;
3359 				ipv6libdir=/usr/local/v6/lib])
3360 			;;
3361 		esac
3362 		if test "$ipv6type" != "unknown"; then
3363 			break
3364 		fi
3365 	done
3366 	AC_MSG_RESULT($ipv6type)
3367 fi
3368 
3369 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
3370 	if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
3371 		LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
3372 		echo "using lib$ipv6lib"
3373 	else
3374 		if test $ipv6trylibc = "yes"; then
3375 			echo "using libc"
3376 		else
3377 			echo 'Fatal: no $ipv6lib library found.  cannot continue.'
3378 			echo "You need to fetch lib$ipv6lib.a from appropriate"
3379 			echo 'ipv6 kit and compile beforehand.'
3380 			exit 1
3381 		fi
3382 	fi
3383 fi
3384 
3385 AC_MSG_CHECKING(for CAN_RAW_FD_FRAMES)
3386 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ /* CAN_RAW_FD_FRAMES available check */
3387 #include <linux/can/raw.h>]],
3388 [[int can_raw_fd_frames = CAN_RAW_FD_FRAMES;]])],[
3389   AC_DEFINE(HAVE_LINUX_CAN_RAW_FD_FRAMES, 1, [Define if compiling using Linux 3.6 or later.])
3390   AC_MSG_RESULT(yes)
3391 ],[
3392   AC_MSG_RESULT(no)
3393 ])
3394 
3395 # Check for --with-doc-strings
3396 AC_MSG_CHECKING(for --with-doc-strings)
3397 AC_ARG_WITH(doc-strings,
3398             AS_HELP_STRING([--with(out)-doc-strings], [disable/enable documentation strings]))
3399 
3400 if test -z "$with_doc_strings"
3401 then with_doc_strings="yes"
3402 fi
3403 if test "$with_doc_strings" != "no"
3404 then
3405     AC_DEFINE(WITH_DOC_STRINGS, 1,
3406       [Define if you want documentation strings in extension modules])
3407 fi
3408 AC_MSG_RESULT($with_doc_strings)
3409 
3410 # Check for Python-specific malloc support
3411 AC_MSG_CHECKING(for --with-pymalloc)
3412 AC_ARG_WITH(pymalloc,
3413             AS_HELP_STRING([--with(out)-pymalloc], [disable/enable specialized mallocs]))
3414 
3415 if test -z "$with_pymalloc"
3416 then
3417     with_pymalloc="yes"
3418 fi
3419 if test "$with_pymalloc" != "no"
3420 then
3421     AC_DEFINE(WITH_PYMALLOC, 1,
3422      [Define if you want to compile in Python-specific mallocs])
3423     ABIFLAGS="${ABIFLAGS}m"
3424 fi
3425 AC_MSG_RESULT($with_pymalloc)
3426 
3427 # Check for --with-c-locale-coercion
3428 AC_MSG_CHECKING(for --with-c-locale-coercion)
3429 AC_ARG_WITH(c-locale-coercion,
3430             AS_HELP_STRING([--with(out)-c-locale-coercion],
3431               [disable/enable C locale coercion to a UTF-8 based locale]))
3432 
3433 if test -z "$with_c_locale_coercion"
3434 then
3435     with_c_locale_coercion="yes"
3436 fi
3437 if test "$with_c_locale_coercion" != "no"
3438 then
3439     AC_DEFINE(PY_COERCE_C_LOCALE, 1,
3440       [Define if you want to coerce the C locale to a UTF-8 based locale])
3441 fi
3442 AC_MSG_RESULT($with_c_locale_coercion)
3443 
3444 # Check for Valgrind support
3445 AC_MSG_CHECKING([for --with-valgrind])
3446 AC_ARG_WITH([valgrind],
3447   AS_HELP_STRING([--with-valgrind], [Enable Valgrind support]),,
3448   with_valgrind=no)
3449 AC_MSG_RESULT([$with_valgrind])
3450 if test "$with_valgrind" != no; then
3451     AC_CHECK_HEADER([valgrind/valgrind.h],
3452       [AC_DEFINE([WITH_VALGRIND], 1, [Define if you want pymalloc to be disabled when running under valgrind])],
3453       [AC_MSG_ERROR([Valgrind support requested but headers not available])]
3454     )
3455     OPT="-DDYNAMIC_ANNOTATIONS_ENABLED=1 $OPT"
3456 fi
3457 
3458 # Check for DTrace support
3459 AC_MSG_CHECKING(for --with-dtrace)
3460 AC_ARG_WITH(dtrace,
3461   AC_HELP_STRING(--with(out)-dtrace, [disable/enable DTrace support]),,
3462   with_dtrace=no)
3463 AC_MSG_RESULT($with_dtrace)
3464 
3465 AC_SUBST(DTRACE)
3466 AC_SUBST(DFLAGS)
3467 AC_SUBST(DTRACE_HEADERS)
3468 AC_SUBST(DTRACE_OBJS)
3469 DTRACE=
3470 DFLAGS=
3471 DTRACE_HEADERS=
3472 DTRACE_OBJS=
3473 
3474 if test "$with_dtrace" = "yes"
3475 then
3476     AC_PATH_PROG(DTRACE, [dtrace], [not found])
3477     if test "$DTRACE" = "not found"; then
3478         AC_MSG_ERROR([dtrace command not found on \$PATH])
3479     fi
3480     AC_DEFINE(WITH_DTRACE, 1, [Define if you want to compile in DTrace support])
3481     DTRACE_HEADERS="Include/pydtrace_probes.h"
3482 
3483     # On OS X, DTrace providers do not need to be explicitly compiled and
3484     # linked into the binary. Correspondingly, dtrace(1) is missing the ELF
3485     # generation flag '-G'. We check for presence of this flag, rather than
3486     # hardcoding support by OS, in the interest of robustness.
3487     AC_CACHE_CHECK([whether DTrace probes require linking],
3488         [ac_cv_dtrace_link], [dnl
3489             ac_cv_dtrace_link=no
3490             echo 'BEGIN' > conftest.d
3491             "$DTRACE" -G -s conftest.d -o conftest.o > /dev/null 2>&1 && \
3492                 ac_cv_dtrace_link=yes
3493       ])
3494     if test "$ac_cv_dtrace_link" = "yes"; then
3495         DTRACE_OBJS="Python/pydtrace.o"
3496     fi
3497 fi
3498 
3499 # -I${DLINCLDIR} is added to the compile rule for importdl.o
3500 AC_SUBST(DLINCLDIR)
3501 DLINCLDIR=.
3502 
3503 # the dlopen() function means we might want to use dynload_shlib.o. some
3504 # platforms, such as AIX, have dlopen(), but don't want to use it.
3505 AC_CHECK_FUNCS(dlopen)
3506 
3507 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
3508 # loading of modules.
3509 AC_SUBST(DYNLOADFILE)
3510 AC_MSG_CHECKING(DYNLOADFILE)
3511 if test -z "$DYNLOADFILE"
3512 then
3513 	case $ac_sys_system/$ac_sys_release in
3514 	AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
3515 	if test "$ac_cv_func_dlopen" = yes
3516 	then DYNLOADFILE="dynload_shlib.o"
3517 	else DYNLOADFILE="dynload_aix.o"
3518 	fi
3519 	;;
3520 	hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
3521 	*)
3522 	# use dynload_shlib.c and dlopen() if we have it; otherwise stub
3523 	# out any dynamic loading
3524 	if test "$ac_cv_func_dlopen" = yes
3525 	then DYNLOADFILE="dynload_shlib.o"
3526 	else DYNLOADFILE="dynload_stub.o"
3527 	fi
3528 	;;
3529 	esac
3530 fi
3531 AC_MSG_RESULT($DYNLOADFILE)
3532 if test "$DYNLOADFILE" != "dynload_stub.o"
3533 then
3534 	AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
3535         [Defined when any dynamic module loading is enabled.])
3536 fi
3537 
3538 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
3539 
3540 AC_SUBST(MACHDEP_OBJS)
3541 AC_MSG_CHECKING(MACHDEP_OBJS)
3542 if test -z "$MACHDEP_OBJS"
3543 then
3544 	MACHDEP_OBJS=$extra_machdep_objs
3545 else
3546 	MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
3547 fi
3548 if test -z "$MACHDEP_OBJS"; then
3549   AC_MSG_RESULT([none])
3550 else
3551   AC_MSG_RESULT([$MACHDEP_OBJS])
3552 fi
3553 
3554 # checks for library functions
3555 AC_CHECK_FUNCS(alarm accept4 setitimer getitimer bind_textdomain_codeset chown \
3556  clock confstr ctermid dup3 execv faccessat fchmod fchmodat fchown fchownat \
3557  fexecve fdopendir fork fpathconf fstatat ftime ftruncate futimesat \
3558  futimens futimes gai_strerror getentropy \
3559  getgrouplist getgroups getlogin getloadavg getpeername getpgid getpid \
3560  getpriority getresuid getresgid getpwent getspnam getspent getsid getwd \
3561  if_nameindex \
3562  initgroups kill killpg lchown lockf linkat lstat lutimes mmap \
3563  memrchr mbrtowc mkdirat mkfifo \
3564  mkfifoat mknod mknodat mktime mremap nice openat pathconf pause pipe2 plock poll \
3565  posix_fallocate posix_fadvise posix_spawn pread preadv preadv2 \
3566  pthread_init pthread_kill putenv pwrite pwritev pwritev2 readlink readlinkat readv realpath renameat \
3567  sem_open sem_timedwait sem_getvalue sem_unlink sendfile setegid seteuid \
3568  setgid sethostname \
3569  setlocale setregid setreuid setresuid setresgid setsid setpgid setpgrp setpriority setuid setvbuf \
3570  sched_get_priority_max sched_setaffinity sched_setscheduler sched_setparam \
3571  sched_rr_get_interval \
3572  sigaction sigaltstack siginterrupt sigpending sigrelse \
3573  sigtimedwait sigwait sigwaitinfo snprintf strftime strlcpy symlinkat sync \
3574  sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
3575  truncate uname unlinkat unsetenv utimensat utimes waitid waitpid wait3 wait4 \
3576  wcscoll wcsftime wcsxfrm wmemcmp writev _getpty)
3577 
3578 # Force lchmod off for Linux. Linux disallows changing the mode of symbolic
3579 # links. Some libc implementations have a stub lchmod implementation that always
3580 # returns an error.
3581 if test "$MACHDEP" != linux; then
3582   AC_CHECK_FUNCS(lchmod)
3583 fi
3584 
3585 AC_CHECK_DECL(dirfd,
3586     AC_DEFINE(HAVE_DIRFD, 1,
3587               Define if you have the 'dirfd' function or macro.), ,
3588       [#include <sys/types.h>
3589        #include <dirent.h>])
3590 
3591 # For some functions, having a definition is not sufficient, since
3592 # we want to take their address.
3593 AC_MSG_CHECKING(for chroot)
3594 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=chroot]])],
3595   [AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
3596    AC_MSG_RESULT(yes)],
3597   [AC_MSG_RESULT(no)
3598 ])
3599 AC_MSG_CHECKING(for link)
3600 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=link]])],
3601   [AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
3602    AC_MSG_RESULT(yes)],
3603   [AC_MSG_RESULT(no)
3604 ])
3605 AC_MSG_CHECKING(for symlink)
3606 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=symlink]])],
3607   [AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
3608    AC_MSG_RESULT(yes)],
3609   [AC_MSG_RESULT(no)
3610 ])
3611 AC_MSG_CHECKING(for fchdir)
3612 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=fchdir]])],
3613   [AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
3614    AC_MSG_RESULT(yes)],
3615   [AC_MSG_RESULT(no)
3616 ])
3617 AC_MSG_CHECKING(for fsync)
3618 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=fsync]])],
3619   [AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
3620    AC_MSG_RESULT(yes)],
3621   [AC_MSG_RESULT(no)
3622 ])
3623 AC_MSG_CHECKING(for fdatasync)
3624 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=fdatasync]])],
3625   [AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
3626    AC_MSG_RESULT(yes)],
3627   [AC_MSG_RESULT(no)
3628 ])
3629 AC_MSG_CHECKING(for epoll)
3630 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/epoll.h>]], [[void *x=epoll_create]])],
3631   [AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
3632    AC_MSG_RESULT(yes)],
3633   [AC_MSG_RESULT(no)
3634 ])
3635 AC_MSG_CHECKING(for epoll_create1)
3636 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/epoll.h>]], [[void *x=epoll_create1]])],
3637   [AC_DEFINE(HAVE_EPOLL_CREATE1, 1, Define if you have the 'epoll_create1' function.)
3638    AC_MSG_RESULT(yes)],
3639   [AC_MSG_RESULT(no)
3640 ])
3641 AC_MSG_CHECKING(for kqueue)
3642 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3643 #include <sys/types.h>
3644 #include <sys/event.h>
3645     ]], [[int x=kqueue()]])],
3646   [AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
3647    AC_MSG_RESULT(yes)],
3648   [AC_MSG_RESULT(no)
3649 ])
3650 AC_MSG_CHECKING(for prlimit)
3651 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3652 #include <sys/time.h>
3653 #include <sys/resource.h>
3654     ]], [[void *x=prlimit]])],
3655   [AC_DEFINE(HAVE_PRLIMIT, 1, Define if you have the 'prlimit' functions.)
3656    AC_MSG_RESULT(yes)],
3657   [AC_MSG_RESULT(no)
3658 ])
3659 
3660 # On some systems (eg. FreeBSD 5), we would find a definition of the
3661 # functions ctermid_r, setgroups in the library, but no prototype
3662 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
3663 # address to avoid compiler warnings and potential miscompilations
3664 # because of the missing prototypes.
3665 
3666 AC_MSG_CHECKING(for ctermid_r)
3667 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3668 #include <stdio.h>
3669 ]], [[void* p = ctermid_r]])],
3670   [AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
3671    AC_MSG_RESULT(yes)],
3672   [AC_MSG_RESULT(no)
3673 ])
3674 
3675 AC_CACHE_CHECK([for flock declaration], [ac_cv_flock_decl],
3676   [AC_COMPILE_IFELSE(
3677     [AC_LANG_PROGRAM(
3678       [#include <sys/file.h>],
3679       [void* p = flock]
3680     )],
3681     [ac_cv_flock_decl=yes],
3682     [ac_cv_flock_decl=no]
3683   )
3684 ])
3685 if test "x${ac_cv_flock_decl}" = xyes; then
3686   AC_CHECK_FUNCS(flock,,
3687     AC_CHECK_LIB(bsd,flock,
3688       [AC_DEFINE(HAVE_FLOCK)
3689        AC_DEFINE(FLOCK_NEEDS_LIBBSD, 1, Define if flock needs to be linked with bsd library.)
3690     ])
3691   )
3692 fi
3693 
3694 AC_MSG_CHECKING(for getpagesize)
3695 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3696 #include <unistd.h>
3697 ]], [[void* p = getpagesize]])],
3698   [AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
3699    AC_MSG_RESULT(yes)],
3700   [AC_MSG_RESULT(no)
3701 ])
3702 
3703 AC_MSG_CHECKING(for broken unsetenv)
3704 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3705 #include <stdlib.h>
3706 ]], [[int res = unsetenv("DUMMY")]])],
3707   [AC_MSG_RESULT(no)],
3708   [AC_DEFINE(HAVE_BROKEN_UNSETENV, 1, Define if `unsetenv` does not return an int.)
3709    AC_MSG_RESULT(yes)
3710 ])
3711 
3712 dnl check for true
3713 AC_CHECK_PROGS(TRUE, true, /bin/true)
3714 
3715 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
3716 dnl On others, they are in the C library, so we to take no action
3717 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
3718   AC_CHECK_LIB(resolv, inet_aton)
3719 )
3720 
3721 # On Tru64, chflags seems to be present, but calling it will
3722 # exit Python
3723 AC_CACHE_CHECK([for chflags], [ac_cv_have_chflags], [dnl
3724 AC_RUN_IFELSE([AC_LANG_SOURCE([[
3725 #include <sys/stat.h>
3726 #include <unistd.h>
3727 int main(int argc, char*argv[])
3728 {
3729   if(chflags(argv[0], 0) != 0)
3730     return 1;
3731   return 0;
3732 }
3733 ]])],
3734 [ac_cv_have_chflags=yes],
3735 [ac_cv_have_chflags=no],
3736 [ac_cv_have_chflags=cross])
3737 ])
3738 if test "$ac_cv_have_chflags" = cross ; then
3739   AC_CHECK_FUNC([chflags], [ac_cv_have_chflags="yes"], [ac_cv_have_chflags="no"])
3740 fi
3741 if test "$ac_cv_have_chflags" = yes ; then
3742   AC_DEFINE(HAVE_CHFLAGS, 1, [Define to 1 if you have the 'chflags' function.])
3743 fi
3744 
3745 AC_CACHE_CHECK([for lchflags], [ac_cv_have_lchflags], [dnl
3746 AC_RUN_IFELSE([AC_LANG_SOURCE([[
3747 #include <sys/stat.h>
3748 #include <unistd.h>
3749 int main(int argc, char*argv[])
3750 {
3751   if(lchflags(argv[0], 0) != 0)
3752     return 1;
3753   return 0;
3754 }
3755 ]])],[ac_cv_have_lchflags=yes],[ac_cv_have_lchflags=no],[ac_cv_have_lchflags=cross])
3756 ])
3757 if test "$ac_cv_have_lchflags" = cross ; then
3758   AC_CHECK_FUNC([lchflags], [ac_cv_have_lchflags="yes"], [ac_cv_have_lchflags="no"])
3759 fi
3760 if test "$ac_cv_have_lchflags" = yes ; then
3761   AC_DEFINE(HAVE_LCHFLAGS, 1, [Define to 1 if you have the 'lchflags' function.])
3762 fi
3763 
3764 dnl Check if system zlib has *Copy() functions
3765 dnl
3766 dnl On MacOSX the linker will search for dylibs on the entire linker path
3767 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
3768 dnl to revert to a more traditional unix behaviour and make it possible to
3769 dnl override the system libz with a local static library of libz. Temporarily
3770 dnl add that flag to our CFLAGS as well to ensure that we check the version
3771 dnl of libz that will be used by setup.py.
3772 dnl The -L/usr/local/lib is needed as wel to get the same compilation
3773 dnl environment as setup.py (and leaving it out can cause configure to use the
3774 dnl wrong version of the library)
3775 case $ac_sys_system/$ac_sys_release in
3776 Darwin/*)
3777 	_CUR_CFLAGS="${CFLAGS}"
3778 	_CUR_LDFLAGS="${LDFLAGS}"
3779 	CFLAGS="${CFLAGS} -Wl,-search_paths_first"
3780 	LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
3781 	;;
3782 esac
3783 
3784 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, [Define if the zlib library has inflateCopy]))
3785 
3786 case $ac_sys_system/$ac_sys_release in
3787 Darwin/*)
3788 	CFLAGS="${_CUR_CFLAGS}"
3789 	LDFLAGS="${_CUR_LDFLAGS}"
3790 	;;
3791 esac
3792 
3793 AC_MSG_CHECKING(for hstrerror)
3794 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
3795 #include <netdb.h>
3796 ]], [[void* p = hstrerror; hstrerror(0)]])],
3797   [AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
3798    AC_MSG_RESULT(yes)],
3799   [AC_MSG_RESULT(no)
3800 ])
3801 
3802 AC_MSG_CHECKING(for inet_aton)
3803 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
3804 #include <sys/types.h>
3805 #include <sys/socket.h>
3806 #include <netinet/in.h>
3807 #include <arpa/inet.h>
3808 ]], [[void* p = inet_aton;inet_aton(0,0)]])],
3809   [AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
3810    AC_MSG_RESULT(yes)],
3811   [AC_MSG_RESULT(no)
3812 ])
3813 
3814 AC_MSG_CHECKING(for inet_pton)
3815 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3816 #include <sys/types.h>
3817 #include <sys/socket.h>
3818 #include <netinet/in.h>
3819 #include <arpa/inet.h>
3820 ]], [[void* p = inet_pton]])],
3821   [AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
3822    AC_MSG_RESULT(yes)],
3823   [AC_MSG_RESULT(no)
3824 ])
3825 
3826 # On some systems, setgroups is in unistd.h, on others, in grp.h
3827 AC_MSG_CHECKING(for setgroups)
3828 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3829 #include <unistd.h>
3830 #ifdef HAVE_GRP_H
3831 #include <grp.h>
3832 #endif
3833 ]], [[void* p = setgroups]])],
3834   [AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
3835    AC_MSG_RESULT(yes)],
3836   [AC_MSG_RESULT(no)
3837 ])
3838 
3839 # check for openpty and forkpty
3840 
3841 AC_CHECK_FUNCS(openpty,,
3842    AC_CHECK_LIB(util,openpty,
3843      [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
3844      AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
3845    )
3846 )
3847 AC_CHECK_FUNCS(forkpty,,
3848    AC_CHECK_LIB(util,forkpty,
3849      [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
3850      AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
3851    )
3852 )
3853 
3854 # check for long file support functions
3855 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
3856 
3857 AC_REPLACE_FUNCS(dup2 strdup)
3858 AC_CHECK_FUNCS(getpgrp,
3859   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[getpgrp(0);]])],
3860     [AC_DEFINE(GETPGRP_HAVE_ARG, 1, [Define if getpgrp() must be called as getpgrp(0).])],
3861     [])
3862 )
3863 AC_CHECK_FUNCS(setpgrp,
3864   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[setpgrp(0,0);]])],
3865     [AC_DEFINE(SETPGRP_HAVE_ARG, 1, [Define if setpgrp() must be called as setpgrp(0, 0).])],
3866     [])
3867 )
3868 AC_CHECK_FUNCS(gettimeofday,
3869   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/time.h>]],
3870   				     [[gettimeofday((struct timeval*)0,(struct timezone*)0);]])],
3871     [],
3872     [AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
3873       [Define if gettimeofday() does not have second (timezone) argument
3874        This is the case on Motorola V4 (R40V4.2)])
3875     ])
3876 )
3877 
3878 # We search for both crypt and crypt_r as one or the other may be defined
3879 # This gets us our -lcrypt in LIBS when required on the target platform.
3880 AC_SEARCH_LIBS(crypt, crypt)
3881 AC_SEARCH_LIBS(crypt_r, crypt)
3882 
3883 AC_CHECK_FUNC(crypt_r,
3884   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3885 #define _GNU_SOURCE  /* Required for crypt_r()'s prototype in glibc. */
3886 #include <crypt.h>
3887 ]], [[
3888 struct crypt_data d;
3889 char *r = crypt_r("", "", &d);
3890 ]])],
3891     [AC_DEFINE(HAVE_CRYPT_R, 1, [Define if you have the crypt_r() function.])],
3892     [])
3893 )
3894 
3895 AC_CHECK_FUNCS(clock_gettime, [], [
3896     AC_CHECK_LIB(rt, clock_gettime, [
3897         LIBS="$LIBS -lrt"
3898         AC_DEFINE(HAVE_CLOCK_GETTIME, 1)
3899         AC_DEFINE(TIMEMODULE_LIB, [rt],
3900                   [Library needed by timemodule.c: librt may be needed for clock_gettime()])
3901     ])
3902 ])
3903 
3904 AC_CHECK_FUNCS(clock_getres, [], [
3905     AC_CHECK_LIB(rt, clock_getres, [
3906         AC_DEFINE(HAVE_CLOCK_GETRES, 1)
3907     ])
3908 ])
3909 
3910 AC_CHECK_FUNCS(clock_settime, [], [
3911     AC_CHECK_LIB(rt, clock_settime, [
3912         AC_DEFINE(HAVE_CLOCK_SETTIME, 1)
3913     ])
3914 ])
3915 
3916 AC_MSG_CHECKING(for major, minor, and makedev)
3917 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
3918 #if defined(MAJOR_IN_MKDEV)
3919 #include <sys/mkdev.h>
3920 #elif defined(MAJOR_IN_SYSMACROS)
3921 #include <sys/sysmacros.h>
3922 #else
3923 #include <sys/types.h>
3924 #endif
3925 ]], [[
3926   makedev(major(0),minor(0));
3927 ]])],[
3928   AC_DEFINE(HAVE_DEVICE_MACROS, 1,
3929 	    [Define to 1 if you have the device macros.])
3930   AC_MSG_RESULT(yes)
3931 ],[
3932   AC_MSG_RESULT(no)
3933 ])
3934 
3935 # On OSF/1 V5.1, getaddrinfo is available, but a define
3936 # for [no]getaddrinfo in netdb.h.
3937 AC_MSG_CHECKING(for getaddrinfo)
3938 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
3939 #include <sys/types.h>
3940 #include <sys/socket.h>
3941 #include <netdb.h>
3942 #include <stdio.h>
3943 ]], [[getaddrinfo(NULL, NULL, NULL, NULL);]])],
3944 [have_getaddrinfo=yes],
3945 [have_getaddrinfo=no])
3946 AC_MSG_RESULT($have_getaddrinfo)
3947 if test $have_getaddrinfo = yes
3948 then
3949   AC_MSG_CHECKING(getaddrinfo bug)
3950   AC_CACHE_VAL(ac_cv_buggy_getaddrinfo,
3951   AC_RUN_IFELSE([AC_LANG_SOURCE([[[
3952 #include <stdio.h>
3953 #include <sys/types.h>
3954 #include <netdb.h>
3955 #include <string.h>
3956 #include <sys/socket.h>
3957 #include <netinet/in.h>
3958 
3959 int main()
3960 {
3961   int passive, gaierr, inet4 = 0, inet6 = 0;
3962   struct addrinfo hints, *ai, *aitop;
3963   char straddr[INET6_ADDRSTRLEN], strport[16];
3964 
3965   for (passive = 0; passive <= 1; passive++) {
3966     memset(&hints, 0, sizeof(hints));
3967     hints.ai_family = AF_UNSPEC;
3968     hints.ai_flags = passive ? AI_PASSIVE : 0;
3969     hints.ai_socktype = SOCK_STREAM;
3970     hints.ai_protocol = IPPROTO_TCP;
3971     if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
3972       (void)gai_strerror(gaierr);
3973       goto bad;
3974     }
3975     for (ai = aitop; ai; ai = ai->ai_next) {
3976       if (ai->ai_addr == NULL ||
3977           ai->ai_addrlen == 0 ||
3978           getnameinfo(ai->ai_addr, ai->ai_addrlen,
3979                       straddr, sizeof(straddr), strport, sizeof(strport),
3980                       NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
3981         goto bad;
3982       }
3983       switch (ai->ai_family) {
3984       case AF_INET:
3985         if (strcmp(strport, "54321") != 0) {
3986           goto bad;
3987         }
3988         if (passive) {
3989           if (strcmp(straddr, "0.0.0.0") != 0) {
3990             goto bad;
3991           }
3992         } else {
3993           if (strcmp(straddr, "127.0.0.1") != 0) {
3994             goto bad;
3995           }
3996         }
3997         inet4++;
3998         break;
3999       case AF_INET6:
4000         if (strcmp(strport, "54321") != 0) {
4001           goto bad;
4002         }
4003         if (passive) {
4004           if (strcmp(straddr, "::") != 0) {
4005             goto bad;
4006           }
4007         } else {
4008           if (strcmp(straddr, "::1") != 0) {
4009             goto bad;
4010           }
4011         }
4012         inet6++;
4013         break;
4014       case AF_UNSPEC:
4015         goto bad;
4016         break;
4017       default:
4018         /* another family support? */
4019         break;
4020       }
4021     }
4022     freeaddrinfo(aitop);
4023     aitop = NULL;
4024   }
4025 
4026   if (!(inet4 == 0 || inet4 == 2))
4027     goto bad;
4028   if (!(inet6 == 0 || inet6 == 2))
4029     goto bad;
4030 
4031   if (aitop)
4032     freeaddrinfo(aitop);
4033   return 0;
4034 
4035  bad:
4036   if (aitop)
4037     freeaddrinfo(aitop);
4038   return 1;
4039 }
4040 ]]])],
4041 [ac_cv_buggy_getaddrinfo=no],
4042 [ac_cv_buggy_getaddrinfo=yes],
4043 [
4044 if test "${enable_ipv6+set}" = set; then
4045   ac_cv_buggy_getaddrinfo="no -- configured with --(en|dis)able-ipv6"
4046 else
4047   ac_cv_buggy_getaddrinfo=yes
4048 fi]))
4049 fi
4050 
4051 AC_MSG_RESULT($ac_cv_buggy_getaddrinfo)
4052 
4053 if test $have_getaddrinfo = no || test "$ac_cv_buggy_getaddrinfo" = yes
4054 then
4055 	if test $ipv6 = yes
4056 	then
4057 		echo 'Fatal: You must get working getaddrinfo() function.'
4058 		echo '       or you can specify "--disable-ipv6"'.
4059 		exit 1
4060 	fi
4061 else
4062 	AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
4063 fi
4064 
4065 AC_CHECK_FUNCS(getnameinfo)
4066 
4067 # checks for structures
4068 AC_HEADER_TIME
4069 AC_STRUCT_TM
4070 AC_STRUCT_TIMEZONE
4071 AC_CHECK_MEMBERS([struct stat.st_rdev])
4072 AC_CHECK_MEMBERS([struct stat.st_blksize])
4073 AC_CHECK_MEMBERS([struct stat.st_flags])
4074 AC_CHECK_MEMBERS([struct stat.st_gen])
4075 AC_CHECK_MEMBERS([struct stat.st_birthtime])
4076 AC_CHECK_MEMBERS([struct stat.st_blocks])
4077 AC_CHECK_MEMBERS([struct passwd.pw_gecos, struct passwd.pw_passwd], [], [], [[
4078   #include <sys/types.h>
4079   #include <pwd.h>
4080 ]])
4081 # Issue #21085: In Cygwin, siginfo_t does not have si_band field.
4082 AC_CHECK_MEMBERS([siginfo_t.si_band], [], [], [[#include <signal.h>]])
4083 
4084 AC_MSG_CHECKING(for time.h that defines altzone)
4085 AC_CACHE_VAL(ac_cv_header_time_altzone,[
4086   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[return altzone;]])],
4087     [ac_cv_header_time_altzone=yes],
4088     [ac_cv_header_time_altzone=no])
4089   ])
4090 AC_MSG_RESULT($ac_cv_header_time_altzone)
4091 if test $ac_cv_header_time_altzone = yes; then
4092   AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
4093 fi
4094 
4095 was_it_defined=no
4096 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
4097 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
4098 #include <sys/types.h>
4099 #include <sys/select.h>
4100 #include <sys/time.h>
4101 ]], [[;]])],[
4102   AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
4103   [Define if  you can safely include both <sys/select.h> and <sys/time.h>
4104    (which you can't on SCO ODT 3.0).])
4105   was_it_defined=yes
4106 ],[])
4107 AC_MSG_RESULT($was_it_defined)
4108 
4109 AC_MSG_CHECKING(for addrinfo)
4110 AC_CACHE_VAL(ac_cv_struct_addrinfo,
4111 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <netdb.h>]], [[struct addrinfo a]])],
4112   [ac_cv_struct_addrinfo=yes],
4113   [ac_cv_struct_addrinfo=no]))
4114 AC_MSG_RESULT($ac_cv_struct_addrinfo)
4115 if test $ac_cv_struct_addrinfo = yes; then
4116 	AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
4117 fi
4118 
4119 AC_MSG_CHECKING(for sockaddr_storage)
4120 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
4121 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
4122 #		include <sys/types.h>
4123 #		include <sys/socket.h>]], [[struct sockaddr_storage s]])],
4124   [ac_cv_struct_sockaddr_storage=yes],
4125   [ac_cv_struct_sockaddr_storage=no]))
4126 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
4127 if test $ac_cv_struct_sockaddr_storage = yes; then
4128 	AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
4129 fi
4130 
4131 AC_MSG_CHECKING(for sockaddr_alg)
4132 AC_CACHE_VAL(ac_cv_struct_sockaddr_alg,
4133 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
4134 #		include <sys/types.h>
4135 #		include <sys/socket.h>
4136 #		include <linux/if_alg.h>]], [[struct sockaddr_alg s]])],
4137   [ac_cv_struct_sockaddr_alg=yes],
4138   [ac_cv_struct_sockaddr_alg=no]))
4139 AC_MSG_RESULT($ac_cv_struct_sockaddr_alg)
4140 if test $ac_cv_struct_sockaddr_alg = yes; then
4141 	AC_DEFINE(HAVE_SOCKADDR_ALG, 1, [struct sockaddr_alg (linux/if_alg.h)])
4142 fi
4143 
4144 # checks for compiler characteristics
4145 
4146 AC_C_CHAR_UNSIGNED
4147 AC_C_CONST
4148 
4149 works=no
4150 AC_MSG_CHECKING(for working signed char)
4151 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[signed char c;]])],
4152   [works=yes],
4153   [AC_DEFINE(signed, , [Define to empty if the keyword does not work.])]
4154 )
4155 AC_MSG_RESULT($works)
4156 
4157 have_prototypes=no
4158 AC_MSG_CHECKING(for prototypes)
4159 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[int foo(int x) { return 0; }]], [[return foo(10);]])],
4160   [AC_DEFINE(HAVE_PROTOTYPES, 1,
4161      [Define if your compiler supports function prototype])
4162    have_prototypes=yes],
4163   []
4164 )
4165 AC_MSG_RESULT($have_prototypes)
4166 
4167 works=no
4168 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
4169 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
4170 #include <stdarg.h>
4171 int foo(int x, ...) {
4172 	va_list va;
4173 	va_start(va, x);
4174 	va_arg(va, int);
4175 	va_arg(va, char *);
4176 	va_arg(va, double);
4177 	return 0;
4178 }
4179 ]], [[return foo(10, "", 3.14);]])],[
4180   AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
4181    [Define if your compiler supports variable length function prototypes
4182    (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
4183   works=yes
4184 ],[])
4185 AC_MSG_RESULT($works)
4186 
4187 # check for socketpair
4188 AC_MSG_CHECKING(for socketpair)
4189 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
4190 #include <sys/types.h>
4191 #include <sys/socket.h>
4192 ]], [[void *x=socketpair]])],
4193   [AC_DEFINE(HAVE_SOCKETPAIR, 1, [Define if you have the 'socketpair' function.])
4194    AC_MSG_RESULT(yes)],
4195   [AC_MSG_RESULT(no)]
4196 )
4197 
4198 # check if sockaddr has sa_len member
4199 AC_MSG_CHECKING(if sockaddr has sa_len member)
4200 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
4201 #include <sys/socket.h>]], [[struct sockaddr x;
4202 x.sa_len = 0;]])],
4203   [AC_MSG_RESULT(yes)
4204    AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member])],
4205   [AC_MSG_RESULT(no)]
4206 )
4207 
4208 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
4209 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
4210   [Define this if you have some version of gethostbyname_r()])
4211 
4212 AC_CHECK_FUNC(gethostbyname_r, [
4213   AC_DEFINE(HAVE_GETHOSTBYNAME_R)
4214   AC_MSG_CHECKING([gethostbyname_r with 6 args])
4215   OLD_CFLAGS=$CFLAGS
4216   CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
4217   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
4218 #   include <netdb.h>
4219   ]], [[
4220     char *name;
4221     struct hostent *he, *res;
4222     char buffer[2048];
4223     int buflen = 2048;
4224     int h_errnop;
4225 
4226     (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
4227   ]])],[
4228     AC_DEFINE(HAVE_GETHOSTBYNAME_R)
4229     AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
4230     [Define this if you have the 6-arg version of gethostbyname_r().])
4231     AC_MSG_RESULT(yes)
4232   ],[
4233     AC_MSG_RESULT(no)
4234     AC_MSG_CHECKING([gethostbyname_r with 5 args])
4235     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
4236 #       include <netdb.h>
4237       ]], [[
4238         char *name;
4239         struct hostent *he;
4240         char buffer[2048];
4241         int buflen = 2048;
4242         int h_errnop;
4243 
4244         (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
4245       ]])],
4246       [
4247         AC_DEFINE(HAVE_GETHOSTBYNAME_R)
4248         AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
4249           [Define this if you have the 5-arg version of gethostbyname_r().])
4250         AC_MSG_RESULT(yes)
4251       ], [
4252         AC_MSG_RESULT(no)
4253         AC_MSG_CHECKING([gethostbyname_r with 3 args])
4254         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
4255 #           include <netdb.h>
4256           ]], [[
4257             char *name;
4258             struct hostent *he;
4259             struct hostent_data data;
4260 
4261             (void) gethostbyname_r(name, he, &data);
4262           ]])],
4263           [
4264             AC_DEFINE(HAVE_GETHOSTBYNAME_R)
4265             AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
4266               [Define this if you have the 3-arg version of gethostbyname_r().])
4267             AC_MSG_RESULT(yes)
4268           ], [
4269            AC_MSG_RESULT(no)
4270         ])
4271     ])
4272   ])
4273   CFLAGS=$OLD_CFLAGS
4274 ], [
4275   AC_CHECK_FUNCS(gethostbyname)
4276 ])
4277 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
4278 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
4279 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
4280 AC_SUBST(HAVE_GETHOSTBYNAME_R)
4281 AC_SUBST(HAVE_GETHOSTBYNAME)
4282 
4283 # checks for system services
4284 # (none yet)
4285 
4286 # Linux requires this for correct f.p. operations
4287 AC_CHECK_FUNC(__fpu_control,
4288   [],
4289   [AC_CHECK_LIB(ieee, __fpu_control)
4290 ])
4291 
4292 # check for --with-libm=...
4293 AC_SUBST(LIBM)
4294 case $ac_sys_system in
4295 Darwin) ;;
4296 *) LIBM=-lm
4297 esac
4298 AC_MSG_CHECKING(for --with-libm=STRING)
4299 AC_ARG_WITH(libm,
4300             AS_HELP_STRING([--with-libm=STRING], [math library]),
4301 [
4302 if test "$withval" = no
4303 then LIBM=
4304      AC_MSG_RESULT(force LIBM empty)
4305 elif test "$withval" != yes
4306 then LIBM=$withval
4307      AC_MSG_RESULT(set LIBM="$withval")
4308 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
4309 fi],
4310 [AC_MSG_RESULT(default LIBM="$LIBM")])
4311 
4312 # check for --with-libc=...
4313 AC_SUBST(LIBC)
4314 AC_MSG_CHECKING(for --with-libc=STRING)
4315 AC_ARG_WITH(libc,
4316             AS_HELP_STRING([--with-libc=STRING], [C library]),
4317 [
4318 if test "$withval" = no
4319 then LIBC=
4320      AC_MSG_RESULT(force LIBC empty)
4321 elif test "$withval" != yes
4322 then LIBC=$withval
4323      AC_MSG_RESULT(set LIBC="$withval")
4324 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
4325 fi],
4326 [AC_MSG_RESULT(default LIBC="$LIBC")])
4327 
4328 # **************************************
4329 # * Check for gcc x64 inline assembler *
4330 # **************************************
4331 
4332 AC_MSG_CHECKING(for x64 gcc inline assembler)
4333 AC_LINK_IFELSE(   [AC_LANG_PROGRAM([[]], [[
4334   __asm__ __volatile__ ("movq %rcx, %rax");
4335 ]])],[have_gcc_asm_for_x64=yes],[have_gcc_asm_for_x64=no])
4336 AC_MSG_RESULT($have_gcc_asm_for_x64)
4337 if test "$have_gcc_asm_for_x64" = yes
4338 then
4339     AC_DEFINE(HAVE_GCC_ASM_FOR_X64, 1,
4340     [Define if we can use x64 gcc inline assembler])
4341 fi
4342 
4343 # **************************************************
4344 # * Check for various properties of floating point *
4345 # **************************************************
4346 
4347 AC_MSG_CHECKING(whether C doubles are little-endian IEEE 754 binary64)
4348 AC_CACHE_VAL(ac_cv_little_endian_double, [
4349 AC_RUN_IFELSE([AC_LANG_SOURCE([[
4350 #include <string.h>
4351 int main() {
4352     double x = 9006104071832581.0;
4353     if (memcmp(&x, "\x05\x04\x03\x02\x01\xff\x3f\x43", 8) == 0)
4354         return 0;
4355     else
4356         return 1;
4357 }
4358 ]])],
4359 [ac_cv_little_endian_double=yes],
4360 [ac_cv_little_endian_double=no],
4361 [ac_cv_little_endian_double=no])])
4362 AC_MSG_RESULT($ac_cv_little_endian_double)
4363 if test "$ac_cv_little_endian_double" = yes
4364 then
4365   AC_DEFINE(DOUBLE_IS_LITTLE_ENDIAN_IEEE754, 1,
4366   [Define if C doubles are 64-bit IEEE 754 binary format, stored
4367    with the least significant byte first])
4368 fi
4369 
4370 AC_MSG_CHECKING(whether C doubles are big-endian IEEE 754 binary64)
4371 AC_CACHE_VAL(ac_cv_big_endian_double, [
4372 AC_RUN_IFELSE([AC_LANG_SOURCE([[
4373 #include <string.h>
4374 int main() {
4375     double x = 9006104071832581.0;
4376     if (memcmp(&x, "\x43\x3f\xff\x01\x02\x03\x04\x05", 8) == 0)
4377         return 0;
4378     else
4379         return 1;
4380 }
4381 ]])],
4382 [ac_cv_big_endian_double=yes],
4383 [ac_cv_big_endian_double=no],
4384 [ac_cv_big_endian_double=no])])
4385 AC_MSG_RESULT($ac_cv_big_endian_double)
4386 if test "$ac_cv_big_endian_double" = yes
4387 then
4388   AC_DEFINE(DOUBLE_IS_BIG_ENDIAN_IEEE754, 1,
4389   [Define if C doubles are 64-bit IEEE 754 binary format, stored
4390    with the most significant byte first])
4391 fi
4392 
4393 # Some ARM platforms use a mixed-endian representation for doubles.
4394 # While Python doesn't currently have full support for these platforms
4395 # (see e.g., issue 1762561), we can at least make sure that float <-> string
4396 # conversions work.
4397 AC_MSG_CHECKING(whether C doubles are ARM mixed-endian IEEE 754 binary64)
4398 AC_CACHE_VAL(ac_cv_mixed_endian_double, [
4399 AC_RUN_IFELSE([AC_LANG_SOURCE([[
4400 #include <string.h>
4401 int main() {
4402     double x = 9006104071832581.0;
4403     if (memcmp(&x, "\x01\xff\x3f\x43\x05\x04\x03\x02", 8) == 0)
4404         return 0;
4405     else
4406         return 1;
4407 }
4408 ]])],
4409 [ac_cv_mixed_endian_double=yes],
4410 [ac_cv_mixed_endian_double=no],
4411 [ac_cv_mixed_endian_double=no])])
4412 AC_MSG_RESULT($ac_cv_mixed_endian_double)
4413 if test "$ac_cv_mixed_endian_double" = yes
4414 then
4415   AC_DEFINE(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754, 1,
4416   [Define if C doubles are 64-bit IEEE 754 binary format, stored
4417    in ARM mixed-endian order (byte order 45670123)])
4418 fi
4419 
4420 # The short float repr introduced in Python 3.1 requires the
4421 # correctly-rounded string <-> double conversion functions from
4422 # Python/dtoa.c, which in turn require that the FPU uses 53-bit
4423 # rounding; this is a problem on x86, where the x87 FPU has a default
4424 # rounding precision of 64 bits.  For gcc/x86, we can fix this by
4425 # using inline assembler to get and set the x87 FPU control word.
4426 
4427 # This inline assembler syntax may also work for suncc and icc,
4428 # so we try it on all platforms.
4429 
4430 AC_MSG_CHECKING(whether we can use gcc inline assembler to get and set x87 control word)
4431 AC_LINK_IFELSE(   [AC_LANG_PROGRAM([[]], [[
4432   unsigned short cw;
4433   __asm__ __volatile__ ("fnstcw %0" : "=m" (cw));
4434   __asm__ __volatile__ ("fldcw %0" : : "m" (cw));
4435 ]])],[have_gcc_asm_for_x87=yes],[have_gcc_asm_for_x87=no])
4436 AC_MSG_RESULT($have_gcc_asm_for_x87)
4437 if test "$have_gcc_asm_for_x87" = yes
4438 then
4439     AC_DEFINE(HAVE_GCC_ASM_FOR_X87, 1,
4440     [Define if we can use gcc inline assembler to get and set x87 control word])
4441 fi
4442 
4443 AC_MSG_CHECKING(whether we can use gcc inline assembler to get and set mc68881 fpcr)
4444 AC_LINK_IFELSE(   [AC_LANG_PROGRAM([[]], [[
4445   unsigned int fpcr;
4446   __asm__ __volatile__ ("fmove.l %%fpcr,%0" : "=g" (fpcr));
4447   __asm__ __volatile__ ("fmove.l %0,%%fpcr" : : "g" (fpcr));
4448 ]])],[have_gcc_asm_for_mc68881=yes],[have_gcc_asm_for_mc68881=no])
4449 AC_MSG_RESULT($have_gcc_asm_for_mc68881)
4450 if test "$have_gcc_asm_for_mc68881" = yes
4451 then
4452     AC_DEFINE(HAVE_GCC_ASM_FOR_MC68881, 1,
4453     [Define if we can use gcc inline assembler to get and set mc68881 fpcr])
4454 fi
4455 
4456 # Detect whether system arithmetic is subject to x87-style double
4457 # rounding issues.  The result of this test has little meaning on non
4458 # IEEE 754 platforms.  On IEEE 754, test should return 1 if rounding
4459 # mode is round-to-nearest and double rounding issues are present, and
4460 # 0 otherwise.  See http://bugs.python.org/issue2937 for more info.
4461 AC_MSG_CHECKING(for x87-style double rounding)
4462 # $BASECFLAGS may affect the result
4463 ac_save_cc="$CC"
4464 CC="$CC $BASECFLAGS"
4465 AC_RUN_IFELSE([AC_LANG_SOURCE([[
4466 #include <stdlib.h>
4467 #include <math.h>
4468 int main() {
4469     volatile double x, y, z;
4470     /* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */
4471     x = 0.99999999999999989; /* 1-2**-53 */
4472     y = 1./x;
4473     if (y != 1.)
4474         exit(0);
4475     /* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
4476     x = 1e16;
4477     y = 2.99999;
4478     z = x + y;
4479     if (z != 1e16+4.)
4480         exit(0);
4481     /* both tests show evidence of double rounding */
4482     exit(1);
4483 }
4484 ]])],
4485 [ac_cv_x87_double_rounding=no],
4486 [ac_cv_x87_double_rounding=yes],
4487 [ac_cv_x87_double_rounding=no])
4488 CC="$ac_save_cc"
4489 AC_MSG_RESULT($ac_cv_x87_double_rounding)
4490 if test "$ac_cv_x87_double_rounding" = yes
4491 then
4492   AC_DEFINE(X87_DOUBLE_ROUNDING, 1,
4493   [Define if arithmetic is subject to x87-style double rounding issue])
4494 fi
4495 
4496 # ************************************
4497 # * Check for mathematical functions *
4498 # ************************************
4499 
4500 LIBS_SAVE=$LIBS
4501 LIBS="$LIBS $LIBM"
4502 
4503 AC_CHECK_FUNCS([acosh asinh atanh copysign erf erfc expm1 finite gamma])
4504 AC_CHECK_FUNCS([hypot lgamma log1p log2 round tgamma])
4505 AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]])
4506 
4507 # On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
4508 # -0. on some architectures.
4509 AC_MSG_CHECKING(whether tanh preserves the sign of zero)
4510 AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
4511 AC_RUN_IFELSE([AC_LANG_SOURCE([[
4512 #include <math.h>
4513 #include <stdlib.h>
4514 int main() {
4515     /* return 0 if either negative zeros don't exist
4516        on this platform or if negative zeros exist
4517        and tanh(-0.) == -0. */
4518   if (atan2(0., -1.) == atan2(-0., -1.) ||
4519       atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
4520   else exit(1);
4521 }
4522 ]])],
4523 [ac_cv_tanh_preserves_zero_sign=yes],
4524 [ac_cv_tanh_preserves_zero_sign=no],
4525 [ac_cv_tanh_preserves_zero_sign=no])])
4526 AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
4527 if test "$ac_cv_tanh_preserves_zero_sign" = yes
4528 then
4529   AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
4530   [Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
4531 fi
4532 
4533 if test "$ac_cv_func_log1p" = yes
4534 then
4535     # On some versions of AIX, log1p(-0.) returns 0. instead of
4536     # -0.  See issue #9920.
4537     AC_MSG_CHECKING(whether log1p drops the sign of negative zero)
4538     AC_CACHE_VAL(ac_cv_log1p_drops_zero_sign, [
4539     AC_RUN_IFELSE([AC_LANG_SOURCE([[
4540     #include <math.h>
4541     #include <stdlib.h>
4542     int main() {
4543         /* Fail if the signs of log1p(-0.) and -0. can be
4544 	   distinguished. */
4545         if (atan2(log1p(-0.), -1.) == atan2(-0., -1.))
4546             return 0;
4547         else
4548             return 1;
4549     }
4550     ]])],
4551     [ac_cv_log1p_drops_zero_sign=no],
4552     [ac_cv_log1p_drops_zero_sign=yes],
4553     [ac_cv_log1p_drops_zero_sign=no])])
4554     AC_MSG_RESULT($ac_cv_log1p_drops_zero_sign)
4555 fi
4556 if test "$ac_cv_log1p_drops_zero_sign" = yes
4557 then
4558   AC_DEFINE(LOG1P_DROPS_ZERO_SIGN, 1,
4559   [Define if log1p(-0.) is 0. rather than -0.])
4560 fi
4561 
4562 LIBS=$LIBS_SAVE
4563 
4564 # For multiprocessing module, check that sem_open
4565 # actually works.  For FreeBSD versions <= 7.2,
4566 # the kernel module that provides POSIX semaphores
4567 # isn't loaded by default, so an attempt to call
4568 # sem_open results in a 'Signal 12' error.
4569 AC_MSG_CHECKING(whether POSIX semaphores are enabled)
4570 AC_CACHE_VAL(ac_cv_posix_semaphores_enabled,
4571 AC_RUN_IFELSE([AC_LANG_SOURCE([[
4572 #include <unistd.h>
4573 #include <fcntl.h>
4574 #include <stdio.h>
4575 #include <semaphore.h>
4576 #include <sys/stat.h>
4577 
4578 int main(void) {
4579   sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR|S_IWUSR, 0);
4580   if (a == SEM_FAILED) {
4581     perror("sem_open");
4582     return 1;
4583   }
4584   sem_close(a);
4585   sem_unlink("/autoconf");
4586   return 0;
4587 }
4588 ]])],
4589 [ac_cv_posix_semaphores_enabled=yes],
4590 [ac_cv_posix_semaphores_enabled=no],
4591 [ac_cv_posix_semaphores_enabled=yes])
4592 )
4593 AC_MSG_RESULT($ac_cv_posix_semaphores_enabled)
4594 if test $ac_cv_posix_semaphores_enabled = no
4595 then
4596   AC_DEFINE(POSIX_SEMAPHORES_NOT_ENABLED, 1,
4597             [Define if POSIX semaphores aren't enabled on your system])
4598 fi
4599 
4600 # Multiprocessing check for broken sem_getvalue
4601 AC_MSG_CHECKING(for broken sem_getvalue)
4602 AC_CACHE_VAL(ac_cv_broken_sem_getvalue,
4603 AC_RUN_IFELSE([AC_LANG_SOURCE([[
4604 #include <unistd.h>
4605 #include <fcntl.h>
4606 #include <stdio.h>
4607 #include <semaphore.h>
4608 #include <sys/stat.h>
4609 
4610 int main(void){
4611   sem_t *a = sem_open("/autocftw", O_CREAT, S_IRUSR|S_IWUSR, 0);
4612   int count;
4613   int res;
4614   if(a==SEM_FAILED){
4615     perror("sem_open");
4616     return 1;
4617 
4618   }
4619   res = sem_getvalue(a, &count);
4620   sem_close(a);
4621   sem_unlink("/autocftw");
4622   return res==-1 ? 1 : 0;
4623 }
4624 ]])],
4625 [ac_cv_broken_sem_getvalue=no],
4626 [ac_cv_broken_sem_getvalue=yes],
4627 [ac_cv_broken_sem_getvalue=yes])
4628 )
4629 AC_MSG_RESULT($ac_cv_broken_sem_getvalue)
4630 if test $ac_cv_broken_sem_getvalue = yes
4631 then
4632   AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1,
4633   [define to 1 if your sem_getvalue is broken.])
4634 fi
4635 
4636 AC_CHECK_DECLS([RTLD_LAZY, RTLD_NOW, RTLD_GLOBAL, RTLD_LOCAL, RTLD_NODELETE, RTLD_NOLOAD, RTLD_DEEPBIND, RTLD_MEMBER], [], [], [[#include <dlfcn.h>]])
4637 
4638 # determine what size digit to use for Python's longs
4639 AC_MSG_CHECKING([digit size for Python's longs])
4640 AC_ARG_ENABLE(big-digits,
4641 AS_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
4642 [case $enable_big_digits in
4643 yes)
4644   enable_big_digits=30 ;;
4645 no)
4646   enable_big_digits=15 ;;
4647 [15|30])
4648   ;;
4649 *)
4650   AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
4651 esac
4652 AC_MSG_RESULT($enable_big_digits)
4653 AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits])
4654 ],
4655 [AC_MSG_RESULT(no value specified)])
4656 
4657 # check for wchar.h
4658 AC_CHECK_HEADER(wchar.h, [
4659   AC_DEFINE(HAVE_WCHAR_H, 1,
4660   [Define if the compiler provides a wchar.h header file.])
4661   wchar_h="yes"
4662 ],
4663 wchar_h="no"
4664 )
4665 
4666 # determine wchar_t size
4667 if test "$wchar_h" = yes
4668 then
4669   AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
4670 fi
4671 
4672 AC_MSG_CHECKING(for UCS-4 tcl)
4673 have_ucs4_tcl=no
4674 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
4675 #include <tcl.h>
4676 #if TCL_UTF_MAX != 6
4677 # error "NOT UCS4_TCL"
4678 #endif]], [[]])],[
4679   AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
4680   have_ucs4_tcl=yes
4681 ],[])
4682 AC_MSG_RESULT($have_ucs4_tcl)
4683 
4684 # check whether wchar_t is signed or not
4685 if test "$wchar_h" = yes
4686 then
4687   # check whether wchar_t is signed or not
4688   AC_MSG_CHECKING(whether wchar_t is signed)
4689   AC_CACHE_VAL(ac_cv_wchar_t_signed, [
4690   AC_RUN_IFELSE([AC_LANG_SOURCE([[
4691   #include <wchar.h>
4692   int main()
4693   {
4694 	/* Success: exit code 0 */
4695         exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
4696   }
4697   ]])],
4698   [ac_cv_wchar_t_signed=yes],
4699   [ac_cv_wchar_t_signed=no],
4700   [ac_cv_wchar_t_signed=yes])])
4701   AC_MSG_RESULT($ac_cv_wchar_t_signed)
4702 fi
4703 
4704 AC_MSG_CHECKING(whether wchar_t is usable)
4705 # wchar_t is only usable if it maps to an unsigned type
4706 if test "$ac_cv_sizeof_wchar_t" -ge 2 \
4707           -a "$ac_cv_wchar_t_signed" = "no"
4708 then
4709   AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
4710   [Define if you have a useable wchar_t type defined in wchar.h; useable
4711    means wchar_t must be an unsigned type with at least 16 bits. (see
4712    Include/unicodeobject.h).])
4713   AC_MSG_RESULT(yes)
4714 else
4715   AC_MSG_RESULT(no)
4716 fi
4717 
4718 # check for endianness
4719 AC_C_BIGENDIAN
4720 
4721 # ABI version string for Python extension modules.  This appears between the
4722 # periods in shared library file names, e.g. foo.<SOABI>.so.  It is calculated
4723 # from the following attributes which affect the ABI of this Python build (in
4724 # this order):
4725 #
4726 # * The Python implementation (always 'cpython-' for us)
4727 # * The major and minor version numbers
4728 # * --with-pydebug (adds a 'd')
4729 # * --with-pymalloc (adds a 'm')
4730 # * --with-wide-unicode (adds a 'u')
4731 #
4732 # Thus for example, Python 3.2 built with wide unicode, pydebug, and pymalloc,
4733 # would get a shared library ABI version tag of 'cpython-32dmu' and shared
4734 # libraries would be named 'foo.cpython-32dmu.so'.
4735 AC_SUBST(SOABI)
4736 AC_MSG_CHECKING(ABIFLAGS)
4737 AC_MSG_RESULT($ABIFLAGS)
4738 AC_MSG_CHECKING(SOABI)
4739 SOABI='cpython-'`echo $VERSION | tr -d .`${ABIFLAGS}${PLATFORM_TRIPLET:+-$PLATFORM_TRIPLET}
4740 AC_MSG_RESULT($SOABI)
4741 
4742 AC_SUBST(EXT_SUFFIX)
4743 case $ac_sys_system in
4744     Linux*|GNU*|Darwin)
4745 	EXT_SUFFIX=.${SOABI}${SHLIB_SUFFIX};;
4746     *)
4747 	EXT_SUFFIX=${SHLIB_SUFFIX};;
4748 esac
4749 
4750 AC_MSG_CHECKING(LDVERSION)
4751 LDVERSION='$(VERSION)$(ABIFLAGS)'
4752 AC_MSG_RESULT($LDVERSION)
4753 
4754 dnl define LIBPL after ABIFLAGS and LDVERSION is defined.
4755 AC_SUBST(PY_ENABLE_SHARED)
4756 if test x$PLATFORM_TRIPLET = x; then
4757   LIBPL='$(prefix)'"/lib/python${VERSION}/config-${LDVERSION}"
4758 else
4759   LIBPL='$(prefix)'"/lib/python${VERSION}/config-${LDVERSION}-${PLATFORM_TRIPLET}"
4760 fi
4761 AC_SUBST(LIBPL)
4762 
4763 # Check whether right shifting a negative integer extends the sign bit
4764 # or fills with zeros (like the Cray J90, according to Tim Peters).
4765 AC_MSG_CHECKING(whether right shift extends the sign bit)
4766 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
4767 AC_RUN_IFELSE([AC_LANG_SOURCE([[
4768 int main()
4769 {
4770 	exit(((-1)>>3 == -1) ? 0 : 1);
4771 }
4772 ]])],
4773 [ac_cv_rshift_extends_sign=yes],
4774 [ac_cv_rshift_extends_sign=no],
4775 [ac_cv_rshift_extends_sign=yes])])
4776 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
4777 if test "$ac_cv_rshift_extends_sign" = no
4778 then
4779   AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
4780   [Define if i>>j for signed int i does not extend the sign bit
4781    when i < 0])
4782 fi
4783 
4784 # check for getc_unlocked and related locking functions
4785 AC_MSG_CHECKING(for getc_unlocked() and friends)
4786 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
4787 AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>]], [[
4788 	FILE *f = fopen("/dev/null", "r");
4789 	flockfile(f);
4790 	getc_unlocked(f);
4791 	funlockfile(f);
4792 ]])],[ac_cv_have_getc_unlocked=yes],[ac_cv_have_getc_unlocked=no])])
4793 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
4794 if test "$ac_cv_have_getc_unlocked" = yes
4795 then
4796   AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
4797   [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
4798 fi
4799 
4800 # check where readline lives
4801 # save the value of LIBS so we don't actually link Python with readline
4802 LIBS_no_readline=$LIBS
4803 
4804 # On some systems we need to link readline to a termcap compatible
4805 # library.  NOTE: Keep the precedence of listed libraries synchronised
4806 # with setup.py.
4807 py_cv_lib_readline=no
4808 AC_MSG_CHECKING([how to link readline libs])
4809 for py_libtermcap in "" tinfo ncursesw ncurses curses termcap; do
4810   if test -z "$py_libtermcap"; then
4811     READLINE_LIBS="-lreadline"
4812   else
4813     READLINE_LIBS="-lreadline -l$py_libtermcap"
4814   fi
4815   LIBS="$READLINE_LIBS $LIBS_no_readline"
4816   AC_LINK_IFELSE(
4817     [AC_LANG_CALL([],[readline])],
4818     [py_cv_lib_readline=yes])
4819   if test $py_cv_lib_readline = yes; then
4820     break
4821   fi
4822 done
4823 # Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
4824 #AC_SUBST([READLINE_LIBS])
4825 if test $py_cv_lib_readline = no; then
4826   AC_MSG_RESULT([none])
4827 else
4828   AC_MSG_RESULT([$READLINE_LIBS])
4829   AC_DEFINE(HAVE_LIBREADLINE, 1,
4830     [Define if you have the readline library (-lreadline).])
4831 fi
4832 
4833 # check for readline 2.2
4834 AC_PREPROC_IFELSE([AC_LANG_SOURCE([[#include <readline/readline.h>]])],
4835   [have_readline=yes],
4836   [have_readline=no]
4837 )
4838 if test $have_readline = yes
4839 then
4840   AC_EGREP_HEADER([extern int rl_completion_append_character;],
4841   [readline/readline.h],
4842   AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
4843   [Define if you have readline 2.2]), )
4844   AC_EGREP_HEADER([extern int rl_completion_suppress_append;],
4845   [readline/readline.h],
4846   AC_DEFINE(HAVE_RL_COMPLETION_SUPPRESS_APPEND, 1,
4847   [Define if you have rl_completion_suppress_append]), )
4848 fi
4849 
4850 # check for readline 4.0
4851 AC_CHECK_LIB(readline, rl_pre_input_hook,
4852 	AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
4853         [Define if you have readline 4.0]), ,$READLINE_LIBS)
4854 
4855 # also in 4.0
4856 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
4857 	AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
4858         [Define if you have readline 4.0]), ,$READLINE_LIBS)
4859 
4860 # also in 4.0, but not in editline
4861 AC_CHECK_LIB(readline, rl_resize_terminal,
4862 	AC_DEFINE(HAVE_RL_RESIZE_TERMINAL, 1,
4863         [Define if you have readline 4.0]), ,$READLINE_LIBS)
4864 
4865 # check for readline 4.2
4866 AC_CHECK_LIB(readline, rl_completion_matches,
4867 	AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
4868         [Define if you have readline 4.2]), ,$READLINE_LIBS)
4869 
4870 # also in readline 4.2
4871 AC_PREPROC_IFELSE([AC_LANG_SOURCE([[#include <readline/readline.h>]])],
4872   [have_readline=yes],
4873   [have_readline=no]
4874 )
4875 if test $have_readline = yes
4876 then
4877   AC_EGREP_HEADER([extern int rl_catch_signals;],
4878   [readline/readline.h],
4879   AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
4880   [Define if you can turn off readline's signal handling.]), )
4881 fi
4882 
4883 AC_CHECK_LIB(readline, append_history,
4884 	AC_DEFINE(HAVE_RL_APPEND_HISTORY, 1,
4885         [Define if readline supports append_history]), ,$READLINE_LIBS)
4886 
4887 # End of readline checks: restore LIBS
4888 LIBS=$LIBS_no_readline
4889 
4890 AC_MSG_CHECKING(for broken nice())
4891 AC_CACHE_VAL(ac_cv_broken_nice, [
4892 AC_RUN_IFELSE([AC_LANG_SOURCE([[
4893 #include <stdlib.h>
4894 #include <unistd.h>
4895 int main()
4896 {
4897 	int val1 = nice(1);
4898 	if (val1 != -1 && val1 == nice(2))
4899 		exit(0);
4900 	exit(1);
4901 }
4902 ]])],
4903 [ac_cv_broken_nice=yes],
4904 [ac_cv_broken_nice=no],
4905 [ac_cv_broken_nice=no])])
4906 AC_MSG_RESULT($ac_cv_broken_nice)
4907 if test "$ac_cv_broken_nice" = yes
4908 then
4909   AC_DEFINE(HAVE_BROKEN_NICE, 1,
4910   [Define if nice() returns success/failure instead of the new priority.])
4911 fi
4912 
4913 AC_MSG_CHECKING(for broken poll())
4914 AC_CACHE_VAL(ac_cv_broken_poll,
4915 AC_RUN_IFELSE([AC_LANG_SOURCE([[
4916 #include <poll.h>
4917 
4918 int main()
4919 {
4920     struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
4921     int poll_test;
4922 
4923     close (42);
4924 
4925     poll_test = poll(&poll_struct, 1, 0);
4926     if (poll_test < 0)
4927         return 0;
4928     else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
4929         return 0;
4930     else
4931         return 1;
4932 }
4933 ]])],
4934 [ac_cv_broken_poll=yes],
4935 [ac_cv_broken_poll=no],
4936 [ac_cv_broken_poll=no]))
4937 AC_MSG_RESULT($ac_cv_broken_poll)
4938 if test "$ac_cv_broken_poll" = yes
4939 then
4940   AC_DEFINE(HAVE_BROKEN_POLL, 1,
4941       [Define if poll() sets errno on invalid file descriptors.])
4942 fi
4943 
4944 # check tzset(3) exists and works like we expect it to
4945 AC_MSG_CHECKING(for working tzset())
4946 AC_CACHE_VAL(ac_cv_working_tzset, [
4947 AC_RUN_IFELSE([AC_LANG_SOURCE([[
4948 #include <stdlib.h>
4949 #include <time.h>
4950 #include <string.h>
4951 
4952 #if HAVE_TZNAME
4953 extern char *tzname[];
4954 #endif
4955 
4956 int main()
4957 {
4958 	/* Note that we need to ensure that not only does tzset(3)
4959 	   do 'something' with localtime, but it works as documented
4960 	   in the library reference and as expected by the test suite.
4961 	   This includes making sure that tzname is set properly if
4962 	   tm->tm_zone does not exist since it is the alternative way
4963 	   of getting timezone info.
4964 
4965 	   Red Hat 6.2 doesn't understand the southern hemisphere
4966 	   after New Year's Day.
4967 	*/
4968 
4969 	time_t groundhogday = 1044144000; /* GMT-based */
4970 	time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
4971 
4972 	putenv("TZ=UTC+0");
4973 	tzset();
4974 	if (localtime(&groundhogday)->tm_hour != 0)
4975 	    exit(1);
4976 #if HAVE_TZNAME
4977 	/* For UTC, tzname[1] is sometimes "", sometimes "   " */
4978 	if (strcmp(tzname[0], "UTC") ||
4979 		(tzname[1][0] != 0 && tzname[1][0] != ' '))
4980 	    exit(1);
4981 #endif
4982 
4983 	putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
4984 	tzset();
4985 	if (localtime(&groundhogday)->tm_hour != 19)
4986 	    exit(1);
4987 #if HAVE_TZNAME
4988 	if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
4989 	    exit(1);
4990 #endif
4991 
4992 	putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
4993 	tzset();
4994 	if (localtime(&groundhogday)->tm_hour != 11)
4995 	    exit(1);
4996 #if HAVE_TZNAME
4997 	if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
4998 	    exit(1);
4999 #endif
5000 
5001 #if HAVE_STRUCT_TM_TM_ZONE
5002 	if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
5003 	    exit(1);
5004 	if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
5005 	    exit(1);
5006 #endif
5007 
5008 	exit(0);
5009 }
5010 ]])],
5011 [ac_cv_working_tzset=yes],
5012 [ac_cv_working_tzset=no],
5013 [ac_cv_working_tzset=no])])
5014 AC_MSG_RESULT($ac_cv_working_tzset)
5015 if test "$ac_cv_working_tzset" = yes
5016 then
5017   AC_DEFINE(HAVE_WORKING_TZSET, 1,
5018   [Define if tzset() actually switches the local timezone in a meaningful way.])
5019 fi
5020 
5021 # Look for subsecond timestamps in struct stat
5022 AC_MSG_CHECKING(for tv_nsec in struct stat)
5023 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
5024 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/stat.h>]], [[
5025 struct stat st;
5026 st.st_mtim.tv_nsec = 1;
5027 ]])],
5028 [ac_cv_stat_tv_nsec=yes],
5029 [ac_cv_stat_tv_nsec=no]))
5030 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
5031 if test "$ac_cv_stat_tv_nsec" = yes
5032 then
5033   AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
5034   [Define if you have struct stat.st_mtim.tv_nsec])
5035 fi
5036 
5037 # Look for BSD style subsecond timestamps in struct stat
5038 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
5039 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
5040 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/stat.h>]], [[
5041 struct stat st;
5042 st.st_mtimespec.tv_nsec = 1;
5043 ]])],
5044 [ac_cv_stat_tv_nsec2=yes],
5045 [ac_cv_stat_tv_nsec2=no]))
5046 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
5047 if test "$ac_cv_stat_tv_nsec2" = yes
5048 then
5049   AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
5050   [Define if you have struct stat.st_mtimensec])
5051 fi
5052 
5053 # first curses header check
5054 ac_save_cppflags="$CPPFLAGS"
5055 if test "$cross_compiling" = no; then
5056   CPPFLAGS="$CPPFLAGS -I/usr/include/ncursesw"
5057 fi
5058 
5059 AC_CHECK_HEADERS(curses.h ncurses.h)
5060 
5061 # On Solaris, term.h requires curses.h
5062 AC_CHECK_HEADERS(term.h,,,[
5063 #ifdef HAVE_CURSES_H
5064 #include <curses.h>
5065 #endif
5066 ])
5067 
5068 # On HP/UX 11.0, mvwdelch is a block with a return statement
5069 AC_MSG_CHECKING(whether mvwdelch is an expression)
5070 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
5071 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
5072   int rtn;
5073   rtn = mvwdelch(0,0,0);
5074 ]])],
5075 [ac_cv_mvwdelch_is_expression=yes],
5076 [ac_cv_mvwdelch_is_expression=no]))
5077 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
5078 
5079 if test "$ac_cv_mvwdelch_is_expression" = yes
5080 then
5081   AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
5082   [Define if mvwdelch in curses.h is an expression.])
5083 fi
5084 
5085 # Issue #25720: ncurses has introduced the NCURSES_OPAQUE symbol making opaque
5086 # structs since version 5.7.  If the macro is defined as zero before including
5087 # [n]curses.h, ncurses will expose fields of the structs regardless of the
5088 # configuration.
5089 AC_MSG_CHECKING(whether WINDOW has _flags)
5090 AC_CACHE_VAL(ac_cv_window_has_flags,
5091 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
5092   #define NCURSES_OPAQUE 0
5093   #include <curses.h>
5094 ]], [[
5095   WINDOW *w;
5096   w->_flags = 0;
5097 ]])],
5098 [ac_cv_window_has_flags=yes],
5099 [ac_cv_window_has_flags=no]))
5100 AC_MSG_RESULT($ac_cv_window_has_flags)
5101 
5102 
5103 if test "$ac_cv_window_has_flags" = yes
5104 then
5105   AC_DEFINE(WINDOW_HAS_FLAGS, 1,
5106   [Define if WINDOW in curses.h offers a field _flags.])
5107 fi
5108 
5109 AC_MSG_CHECKING(for is_pad)
5110 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
5111 #ifndef is_pad
5112 void *x=is_pad
5113 #endif
5114 ]])],
5115   [AC_DEFINE(HAVE_CURSES_IS_PAD, 1, Define if you have the 'is_pad' function or macro.)
5116    AC_MSG_RESULT(yes)],
5117   [AC_MSG_RESULT(no)]
5118 )
5119 
5120 AC_MSG_CHECKING(for is_term_resized)
5121 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=is_term_resized]])],
5122   [AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
5123    AC_MSG_RESULT(yes)],
5124   [AC_MSG_RESULT(no)]
5125 )
5126 
5127 AC_MSG_CHECKING(for resize_term)
5128 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=resize_term]])],
5129   [AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
5130    AC_MSG_RESULT(yes)],
5131   [AC_MSG_RESULT(no)]
5132 )
5133 
5134 AC_MSG_CHECKING(for resizeterm)
5135 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=resizeterm]])],
5136   [AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
5137    AC_MSG_RESULT(yes)],
5138   [AC_MSG_RESULT(no)]
5139 )
5140 
5141 AC_MSG_CHECKING(for immedok)
5142 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
5143 #ifndef immedok
5144 void *x=immedok
5145 #endif
5146 ]])],
5147   [AC_DEFINE(HAVE_CURSES_IMMEDOK, 1, Define if you have the 'immedok' function.)
5148    AC_MSG_RESULT(yes)],
5149   [AC_MSG_RESULT(no)]
5150 )
5151 
5152 AC_MSG_CHECKING(for syncok)
5153 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
5154 #ifndef syncok
5155 void *x=syncok
5156 #endif
5157 ]])],
5158   [AC_DEFINE(HAVE_CURSES_SYNCOK, 1, Define if you have the 'syncok' function.)
5159    AC_MSG_RESULT(yes)],
5160   [AC_MSG_RESULT(no)]
5161 )
5162 
5163 AC_MSG_CHECKING(for wchgat)
5164 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
5165 #ifndef wchgat
5166 void *x=wchgat
5167 #endif
5168 ]])],
5169   [AC_DEFINE(HAVE_CURSES_WCHGAT, 1, Define if you have the 'wchgat' function.)
5170    AC_MSG_RESULT(yes)],
5171   [AC_MSG_RESULT(no)]
5172 )
5173 
5174 AC_MSG_CHECKING(for filter)
5175 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
5176 #ifndef filter
5177 void *x=filter
5178 #endif
5179 ]])],
5180   [AC_DEFINE(HAVE_CURSES_FILTER, 1, Define if you have the 'filter' function.)
5181    AC_MSG_RESULT(yes)],
5182   [AC_MSG_RESULT(no)]
5183 )
5184 
5185 AC_MSG_CHECKING(for has_key)
5186 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
5187 #ifndef has_key
5188 void *x=has_key
5189 #endif
5190 ]])],
5191   [AC_DEFINE(HAVE_CURSES_HAS_KEY, 1, Define if you have the 'has_key' function.)
5192    AC_MSG_RESULT(yes)],
5193   [AC_MSG_RESULT(no)]
5194 )
5195 
5196 AC_MSG_CHECKING(for typeahead)
5197 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
5198 #ifndef typeahead
5199 void *x=typeahead
5200 #endif
5201 ]])],
5202   [AC_DEFINE(HAVE_CURSES_TYPEAHEAD, 1, Define if you have the 'typeahead' function.)
5203    AC_MSG_RESULT(yes)],
5204   [AC_MSG_RESULT(no)]
5205 )
5206 
5207 AC_MSG_CHECKING(for use_env)
5208 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
5209 #ifndef use_env
5210 void *x=use_env
5211 #endif
5212 ]])],
5213   [AC_DEFINE(HAVE_CURSES_USE_ENV, 1, Define if you have the 'use_env' function.)
5214    AC_MSG_RESULT(yes)],
5215   [AC_MSG_RESULT(no)]
5216 )
5217 # last curses configure check
5218 CPPFLAGS=$ac_save_cppflags
5219 
5220 AC_MSG_NOTICE([checking for device files])
5221 
5222 dnl NOTE: Inform user how to proceed with files when cross compiling.
5223 if test "x$cross_compiling" = xyes; then
5224   if test "${ac_cv_file__dev_ptmx+set}" != set; then
5225     AC_MSG_CHECKING([for /dev/ptmx])
5226     AC_MSG_RESULT([not set])
5227     AC_MSG_ERROR([set ac_cv_file__dev_ptmx to yes/no in your CONFIG_SITE file when cross compiling])
5228   fi
5229   if test "${ac_cv_file__dev_ptc+set}" != set; then
5230     AC_MSG_CHECKING([for /dev/ptc])
5231     AC_MSG_RESULT([not set])
5232     AC_MSG_ERROR([set ac_cv_file__dev_ptc to yes/no in your CONFIG_SITE file when cross compiling])
5233   fi
5234 fi
5235 
5236 AC_CHECK_FILE(/dev/ptmx, [], [])
5237 if test "x$ac_cv_file__dev_ptmx" = xyes; then
5238   AC_DEFINE(HAVE_DEV_PTMX, 1,
5239   [Define to 1 if you have the /dev/ptmx device file.])
5240 fi
5241 AC_CHECK_FILE(/dev/ptc, [], [])
5242 if test "x$ac_cv_file__dev_ptc" = xyes; then
5243   AC_DEFINE(HAVE_DEV_PTC, 1,
5244   [Define to 1 if you have the /dev/ptc device file.])
5245 fi
5246 
5247 if test $ac_sys_system = Darwin
5248 then
5249 	LIBS="$LIBS -framework CoreFoundation"
5250 fi
5251 
5252 AC_CACHE_CHECK([for %zd printf() format support], ac_cv_have_size_t_format, [dnl
5253 AC_RUN_IFELSE([AC_LANG_SOURCE([[
5254 #include <stdio.h>
5255 #include <stddef.h>
5256 #include <string.h>
5257 
5258 #ifdef HAVE_SYS_TYPES_H
5259 #include <sys/types.h>
5260 #endif
5261 
5262 #ifdef HAVE_SSIZE_T
5263 typedef ssize_t Py_ssize_t;
5264 #elif SIZEOF_VOID_P == SIZEOF_LONG
5265 typedef long Py_ssize_t;
5266 #else
5267 typedef int Py_ssize_t;
5268 #endif
5269 
5270 int main()
5271 {
5272     char buffer[256];
5273 
5274     if(sprintf(buffer, "%zd", (size_t)123) < 0)
5275        	return 1;
5276 
5277     if (strcmp(buffer, "123"))
5278 	return 1;
5279 
5280     if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
5281        	return 1;
5282 
5283     if (strcmp(buffer, "-123"))
5284 	return 1;
5285 
5286     return 0;
5287 }
5288 ]])],
5289   [ac_cv_have_size_t_format=yes],
5290   [ac_cv_have_size_t_format=no],
5291   [ac_cv_have_size_t_format="cross -- assuming yes"
5292 ])])
5293 if test "$ac_cv_have_size_t_format" != no ; then
5294   AC_DEFINE(PY_FORMAT_SIZE_T, "z",
5295   [Define to printf format modifier for Py_ssize_t])
5296 fi
5297 
5298 AC_CHECK_TYPE(socklen_t,,
5299   AC_DEFINE(socklen_t,int,
5300             [Define to `int' if <sys/socket.h> does not define.]),[
5301 #ifdef HAVE_SYS_TYPES_H
5302 #include <sys/types.h>
5303 #endif
5304 #ifdef HAVE_SYS_SOCKET_H
5305 #include <sys/socket.h>
5306 #endif
5307 ])
5308 
5309 AC_MSG_CHECKING(for broken mbstowcs)
5310 AC_CACHE_VAL(ac_cv_broken_mbstowcs,
5311 AC_RUN_IFELSE([AC_LANG_SOURCE([[
5312 #include <stdio.h>
5313 #include<stdlib.h>
5314 int main() {
5315     size_t len = -1;
5316     const char *str = "text";
5317     len = mbstowcs(NULL, str, 0);
5318     return (len != 4);
5319 }
5320 ]])],
5321 [ac_cv_broken_mbstowcs=no],
5322 [ac_cv_broken_mbstowcs=yes],
5323 [ac_cv_broken_mbstowcs=no]))
5324 AC_MSG_RESULT($ac_cv_broken_mbstowcs)
5325 if test "$ac_cv_broken_mbstowcs" = yes
5326 then
5327   AC_DEFINE(HAVE_BROKEN_MBSTOWCS, 1,
5328   [Define if mbstowcs(NULL, "text", 0) does not return the number of
5329    wide chars that would be converted.])
5330 fi
5331 
5332 # Check for --with-computed-gotos
5333 AC_MSG_CHECKING(for --with-computed-gotos)
5334 AC_ARG_WITH(computed-gotos,
5335             AS_HELP_STRING([--with(out)-computed-gotos],
5336                            [Use computed gotos in evaluation loop (enabled by default on supported compilers)]),
5337 [
5338 if test "$withval" = yes
5339 then
5340   AC_DEFINE(USE_COMPUTED_GOTOS, 1,
5341   [Define if you want to use computed gotos in ceval.c.])
5342   AC_MSG_RESULT(yes)
5343 fi
5344 if test "$withval" = no
5345 then
5346   AC_DEFINE(USE_COMPUTED_GOTOS, 0,
5347   [Define if you want to use computed gotos in ceval.c.])
5348   AC_MSG_RESULT(no)
5349 fi
5350 ],
5351 [AC_MSG_RESULT(no value specified)])
5352 
5353 AC_MSG_CHECKING(whether $CC supports computed gotos)
5354 AC_CACHE_VAL(ac_cv_computed_gotos,
5355 AC_RUN_IFELSE([AC_LANG_SOURCE([[[
5356 int main(int argc, char **argv)
5357 {
5358     static void *targets[1] = { &&LABEL1 };
5359     goto LABEL2;
5360 LABEL1:
5361     return 0;
5362 LABEL2:
5363     goto *targets[0];
5364     return 1;
5365 }
5366 ]]])],
5367 [ac_cv_computed_gotos=yes],
5368 [ac_cv_computed_gotos=no],
5369 [if test "${with_computed_gotos+set}" = set; then
5370    ac_cv_computed_gotos="$with_computed_gotos -- configured --with(out)-computed-gotos"
5371  else
5372    ac_cv_computed_gotos=no
5373  fi]))
5374 AC_MSG_RESULT($ac_cv_computed_gotos)
5375 case "$ac_cv_computed_gotos" in yes*)
5376   AC_DEFINE(HAVE_COMPUTED_GOTOS, 1,
5377   [Define if the C compiler supports computed gotos.])
5378 esac
5379 
5380 case $ac_sys_system in
5381 AIX*)
5382   AC_DEFINE(HAVE_BROKEN_PIPE_BUF, 1, [Define if the system reports an invalid PIPE_BUF value.]) ;;
5383 esac
5384 
5385 
5386 AC_SUBST(THREADHEADERS)
5387 
5388 for h in `(cd $srcdir;echo Python/thread_*.h)`
5389 do
5390   THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
5391 done
5392 
5393 AC_SUBST(SRCDIRS)
5394 SRCDIRS="Parser Objects Python Modules Programs"
5395 AC_MSG_CHECKING(for build directories)
5396 for dir in $SRCDIRS; do
5397     if test ! -d $dir; then
5398         mkdir $dir
5399     fi
5400 done
5401 AC_MSG_RESULT(done)
5402 
5403 # Availability of -O2:
5404 AC_MSG_CHECKING(for -O2)
5405 saved_cflags="$CFLAGS"
5406 CFLAGS="-O2"
5407 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
5408 ]])],[have_O2=yes],[have_O2=no])
5409 AC_MSG_RESULT($have_O2)
5410 CFLAGS="$saved_cflags"
5411 
5412 # _FORTIFY_SOURCE wrappers for memmove and bcopy are incorrect:
5413 # http://sourceware.org/ml/libc-alpha/2010-12/msg00009.html
5414 AC_MSG_CHECKING(for glibc _FORTIFY_SOURCE/memmove bug)
5415 saved_cflags="$CFLAGS"
5416 CFLAGS="-O2 -D_FORTIFY_SOURCE=2"
5417 if test "$have_O2" = no; then
5418     CFLAGS=""
5419 fi
5420 AC_RUN_IFELSE([AC_LANG_SOURCE([[
5421 #include <stdio.h>
5422 #include <stdlib.h>
5423 #include <string.h>
5424 void foo(void *p, void *q) { memmove(p, q, 19); }
5425 int main() {
5426   char a[32] = "123456789000000000";
5427   foo(&a[9], a);
5428   if (strcmp(a, "123456789123456789000000000") != 0)
5429     return 1;
5430   foo(a, &a[9]);
5431   if (strcmp(a, "123456789000000000") != 0)
5432     return 1;
5433   return 0;
5434 }
5435 ]])],
5436 [have_glibc_memmove_bug=no],
5437 [have_glibc_memmove_bug=yes],
5438 [have_glibc_memmove_bug=undefined])
5439 CFLAGS="$saved_cflags"
5440 AC_MSG_RESULT($have_glibc_memmove_bug)
5441 if test "$have_glibc_memmove_bug" = yes; then
5442     AC_DEFINE(HAVE_GLIBC_MEMMOVE_BUG, 1,
5443     [Define if glibc has incorrect _FORTIFY_SOURCE wrappers
5444      for memmove and bcopy.])
5445 fi
5446 
5447 if test "$have_gcc_asm_for_x87" = yes; then
5448     # Some versions of gcc miscompile inline asm:
5449     # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=46491
5450     # http://gcc.gnu.org/ml/gcc/2010-11/msg00366.html
5451     case $CC in
5452         *gcc*)
5453             AC_MSG_CHECKING(for gcc ipa-pure-const bug)
5454             saved_cflags="$CFLAGS"
5455             CFLAGS="-O2"
5456             AC_RUN_IFELSE([AC_LANG_SOURCE([[
5457             __attribute__((noinline)) int
5458             foo(int *p) {
5459               int r;
5460               asm ( "movl \$6, (%1)\n\t"
5461                     "xorl %0, %0\n\t"
5462                     : "=r" (r) : "r" (p) : "memory"
5463               );
5464               return r;
5465             }
5466             int main() {
5467               int p = 8;
5468               if ((foo(&p) ? : p) != 6)
5469                 return 1;
5470               return 0;
5471             }
5472             ]])],
5473             [have_ipa_pure_const_bug=no],
5474             [have_ipa_pure_const_bug=yes],
5475             [have_ipa_pure_const_bug=undefined])
5476             CFLAGS="$saved_cflags"
5477             AC_MSG_RESULT($have_ipa_pure_const_bug)
5478             if test "$have_ipa_pure_const_bug" = yes; then
5479                 AC_DEFINE(HAVE_IPA_PURE_CONST_BUG, 1,
5480                           [Define if gcc has the ipa-pure-const bug.])
5481             fi
5482         ;;
5483     esac
5484 fi
5485 
5486 # Check for stdatomic.h
5487 AC_MSG_CHECKING(for stdatomic.h)
5488 AC_LINK_IFELSE(
5489 [
5490   AC_LANG_SOURCE([[
5491     #include <stdatomic.h>
5492     atomic_int value = ATOMIC_VAR_INIT(1);
5493     int main() {
5494       int loaded_value = atomic_load(&value);
5495       return 0;
5496     }
5497   ]])
5498 ],[have_stdatomic_h=yes],[have_stdatomic_h=no])
5499 
5500 AC_MSG_RESULT($have_stdatomic_h)
5501 
5502 if test "$have_stdatomic_h" = yes; then
5503     AC_DEFINE(HAVE_STD_ATOMIC, 1,
5504               [Has stdatomic.h with atomic_int])
5505 fi
5506 
5507 # Check for GCC >= 4.7 __atomic builtins
5508 AC_MSG_CHECKING(for GCC >= 4.7 __atomic builtins)
5509 AC_LINK_IFELSE(
5510 [
5511   AC_LANG_SOURCE([[
5512     volatile int val = 1;
5513     int main() {
5514       __atomic_load_n(&val, __ATOMIC_SEQ_CST);
5515       return 0;
5516     }
5517   ]])
5518 ],[have_builtin_atomic=yes],[have_builtin_atomic=no])
5519 
5520 AC_MSG_RESULT($have_builtin_atomic)
5521 
5522 if test "$have_builtin_atomic" = yes; then
5523     AC_DEFINE(HAVE_BUILTIN_ATOMIC, 1, [Has builtin atomics])
5524 fi
5525 
5526 # ensurepip option
5527 AC_MSG_CHECKING(for ensurepip)
5528 AC_ARG_WITH(ensurepip,
5529     [AS_HELP_STRING([--with(out)-ensurepip=@<:@=upgrade@:>@],
5530         ["install" or "upgrade" using bundled pip])],
5531     [],
5532     [with_ensurepip=upgrade])
5533 AS_CASE($with_ensurepip,
5534     [yes|upgrade],[ENSUREPIP=upgrade],
5535     [install],[ENSUREPIP=install],
5536     [no],[ENSUREPIP=no],
5537     [AC_MSG_ERROR([--with-ensurepip=upgrade|install|no])])
5538 AC_MSG_RESULT($ENSUREPIP)
5539 AC_SUBST(ENSUREPIP)
5540 
5541 # check if the dirent structure of a d_type field and DT_UNKNOWN is defined
5542 AC_MSG_CHECKING(if the dirent structure of a d_type field)
5543 AC_LINK_IFELSE(
5544 [
5545   AC_LANG_SOURCE([[
5546     #include <dirent.h>
5547 
5548     int main() {
5549       struct dirent entry;
5550       return entry.d_type == DT_UNKNOWN;
5551     }
5552   ]])
5553 ],[have_dirent_d_type=yes],[have_dirent_d_type=no])
5554 AC_MSG_RESULT($have_dirent_d_type)
5555 
5556 if test "$have_dirent_d_type" = yes; then
5557     AC_DEFINE(HAVE_DIRENT_D_TYPE, 1,
5558               [Define to 1 if the dirent structure has a d_type field])
5559 fi
5560 
5561 # check if the Linux getrandom() syscall is available
5562 AC_MSG_CHECKING(for the Linux getrandom() syscall)
5563 AC_LINK_IFELSE(
5564 [
5565   AC_LANG_SOURCE([[
5566     #include <unistd.h>
5567     #include <sys/syscall.h>
5568     #include <linux/random.h>
5569 
5570     int main() {
5571         char buffer[1];
5572         const size_t buflen = sizeof(buffer);
5573         const int flags = GRND_NONBLOCK;
5574         /* ignore the result, Python checks for ENOSYS and EAGAIN at runtime */
5575         (void)syscall(SYS_getrandom, buffer, buflen, flags);
5576         return 0;
5577     }
5578   ]])
5579 ],[have_getrandom_syscall=yes],[have_getrandom_syscall=no])
5580 AC_MSG_RESULT($have_getrandom_syscall)
5581 
5582 if test "$have_getrandom_syscall" = yes; then
5583     AC_DEFINE(HAVE_GETRANDOM_SYSCALL, 1,
5584               [Define to 1 if the Linux getrandom() syscall is available])
5585 fi
5586 
5587 # check if the getrandom() function is available
5588 # the test was written for the Solaris function of <sys/random.h>
5589 AC_MSG_CHECKING(for the getrandom() function)
5590 AC_LINK_IFELSE(
5591 [
5592   AC_LANG_SOURCE([[
5593     #include <sys/random.h>
5594 
5595     int main() {
5596         char buffer[1];
5597         const size_t buflen = sizeof(buffer);
5598         const int flags = 0;
5599         /* ignore the result, Python checks for ENOSYS at runtime */
5600         (void)getrandom(buffer, buflen, flags);
5601         return 0;
5602     }
5603   ]])
5604 ],[have_getrandom=yes],[have_getrandom=no])
5605 AC_MSG_RESULT($have_getrandom)
5606 
5607 if test "$have_getrandom" = yes; then
5608     AC_DEFINE(HAVE_GETRANDOM, 1,
5609               [Define to 1 if the getrandom() function is available])
5610 fi
5611 
5612 # Check for usable OpenSSL
5613 AX_CHECK_OPENSSL([have_openssl=yes],[have_openssl=no])
5614 
5615 if test "$have_openssl" = yes; then
5616     AC_MSG_CHECKING([for X509_VERIFY_PARAM_set1_host in libssl])
5617 
5618     save_LIBS="$LIBS"
5619     save_LDFLAGS="$LDFLAGS"
5620     save_CPPFLAGS="$CPPFLAGS"
5621     LDFLAGS="$LDFLAGS $OPENSSL_LDFLAGS"
5622     LIBS="$OPENSSL_LIBS $LIBS"
5623     CPPFLAGS="$OPENSSL_INCLUDES $CPPFLAGS"
5624 
5625     AC_LINK_IFELSE([AC_LANG_PROGRAM([
5626         [#include <openssl/x509_vfy.h>]
5627     ], [
5628         [X509_VERIFY_PARAM *p = X509_VERIFY_PARAM_new();]
5629         [X509_VERIFY_PARAM_set1_host(p, "localhost", 0);]
5630         [X509_VERIFY_PARAM_set1_ip_asc(p, "127.0.0.1");]
5631         [X509_VERIFY_PARAM_set_hostflags(p, 0);]
5632     ])
5633     ],
5634     [
5635         ac_cv_has_x509_verify_param_set1_host=yes
5636     ],
5637     [
5638         ac_cv_has_x509_verify_param_set1_host=no
5639     ])
5640     AC_MSG_RESULT($ac_cv_has_x509_verify_param_set1_host)
5641     if test "$ac_cv_has_x509_verify_param_set1_host" = "yes"; then
5642         AC_DEFINE(HAVE_X509_VERIFY_PARAM_SET1_HOST, 1,
5643         [Define if libssl has X509_VERIFY_PARAM_set1_host and related function])
5644     fi
5645 
5646     CPPFLAGS="$save_CPPFLAGS"
5647     LDFLAGS="$save_LDFLAGS"
5648     LIBS="$save_LIBS"
5649 fi
5650 
5651 # ssl module default cipher suite string
5652 AH_TEMPLATE(PY_SSL_DEFAULT_CIPHERS,
5653   [Default cipher suites list for ssl module.
5654    1: Python's preferred selection, 2: leave OpenSSL defaults untouched, 0: custom string])
5655 AH_TEMPLATE(PY_SSL_DEFAULT_CIPHER_STRING,
5656   [Cipher suite string for PY_SSL_DEFAULT_CIPHERS=0]
5657 )
5658 
5659 AC_MSG_CHECKING(for --with-ssl-default-suites)
5660 AC_ARG_WITH(ssl-default-suites,
5661             AS_HELP_STRING([--with-ssl-default-suites=@<:@python|openssl|STRING@:>@],
5662                            [Override default cipher suites string,
5663                             python: use Python's preferred selection (default),
5664                             openssl: leave OpenSSL's defaults untouched,
5665                             STRING: use a custom string,
5666                             PROTOCOL_SSLv2 ignores the setting]),
5667 [
5668 AC_MSG_RESULT($withval)
5669 case "$withval" in
5670     python)
5671         AC_DEFINE(PY_SSL_DEFAULT_CIPHERS, 1)
5672         ;;
5673     openssl)
5674         AC_DEFINE(PY_SSL_DEFAULT_CIPHERS, 2)
5675         ;;
5676     *)
5677         AC_DEFINE(PY_SSL_DEFAULT_CIPHERS, 0)
5678         AC_DEFINE_UNQUOTED(PY_SSL_DEFAULT_CIPHER_STRING, "$withval")
5679         ;;
5680 esac
5681 ],
5682 [
5683 AC_MSG_RESULT(python)
5684 AC_DEFINE(PY_SSL_DEFAULT_CIPHERS, 1)
5685 ])
5686 
5687 
5688 # generate output files
5689 AC_CONFIG_FILES(Makefile.pre Misc/python.pc Misc/python-config.sh)
5690 AC_CONFIG_FILES([Modules/ld_so_aix], [chmod +x Modules/ld_so_aix])
5691 AC_OUTPUT
5692 
5693 echo "creating Modules/Setup" >&AS_MESSAGE_FD
5694 if test ! -f Modules/Setup
5695 then
5696 	cp $srcdir/Modules/Setup.dist Modules/Setup
5697 fi
5698 
5699 echo "creating Modules/Setup.local" >&AS_MESSAGE_FD
5700 if test ! -f Modules/Setup.local
5701 then
5702 	echo "# Edit this file for local setup changes" >Modules/Setup.local
5703 fi
5704 
5705 echo "creating Makefile" >&AS_MESSAGE_FD
5706 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
5707 			-s Modules \
5708 			Modules/Setup.local Modules/Setup
5709 mv config.c Modules
5710 
5711 if test "$Py_OPT" = 'false' -a "$Py_DEBUG" != 'true'; then
5712     echo "" >&AS_MESSAGE_FD
5713     echo "" >&AS_MESSAGE_FD
5714     echo "If you want a release build with all stable optimizations active (PGO, etc)," >&AS_MESSAGE_FD
5715     echo "please run ./configure --enable-optimizations" >&AS_MESSAGE_FD
5716     echo "" >&AS_MESSAGE_FD
5717     echo "" >&AS_MESSAGE_FD
5718 fi
5719 
5720