1
dnl ***********************************************
2
dnl * Please run autoreconf to test your changes! *
3
dnl ***********************************************
5
# Set VERSION so we only need to edit in one place (i.e., here)
6
m4_define(PYTHON_VERSION, 3.4)
10
AC_INIT(python, PYTHON_VERSION, http://bugs.python.org/)
12
AC_SUBST(BASECPPFLAGS)
13
if test "$abs_srcdir" != "$abs_builddir"; then
14
# If we're building out-of-tree, we need to make sure the following
15
# resources get picked up before their $srcdir counterparts.
16
# Objects/ -> typeslots.inc
17
# Include/ -> Python-ast.h, graminit.h
18
# Python/ -> importlib.h
19
# (A side effect of this is that these resources will automatically be
20
# regenerated when building out-of-tree, regardless of whether or not
21
# the $srcdir counterpart is up-to-date. This is an acceptable trade
23
BASECPPFLAGS="-IObjects -IInclude -IPython"
32
if test -e $srcdir/.hg/dirstate
34
AC_CHECK_PROG(HAS_HG, hg, found, not-found)
38
if test $HAS_HG = found
40
HGVERSION="hg id -i \$(srcdir)"
41
HGTAG="hg id -t \$(srcdir)"
42
HGBRANCH="hg id -b \$(srcdir)"
49
AC_CONFIG_SRCDIR([Include/object.h])
50
AC_CONFIG_HEADER(pyconfig.h)
56
if test "$cross_compiling" = yes; then
57
AC_MSG_CHECKING([for python interpreter for cross build])
58
if test -z "$PYTHON_FOR_BUILD"; then
59
for interp in python$PACKAGE_VERSION python3 python; do
60
which $interp >/dev/null 2>&1 || continue
61
if $interp -c 'import sys;sys.exit(not sys.version_info@<:@:2@:>@ >= (3,3))'; then
66
if test x$interp = x; then
67
AC_MSG_ERROR([python$PACKAGE_VERSION interpreter not found])
69
AC_MSG_RESULT($interp)
70
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:$(srcdir)/Lib/$(PLATDIR) '$interp
72
elif test "$cross_compiling" = maybe; then
73
AC_MSG_ERROR([Cross compiling required --host=HOST-TUPLE and --build=ARCH])
75
PYTHON_FOR_BUILD='./$(BUILDPYTHON) -E'
77
AC_SUBST(PYTHON_FOR_BUILD)
79
dnl Ensure that if prefix is specified, it does not end in a slash. If
80
dnl it does, we get path names containing '//' which is both ugly and
81
dnl can cause trouble.
83
dnl Last slash shouldn't be stripped if prefix=/
84
if test "$prefix" != "/"; then
85
prefix=`echo "$prefix" | sed -e 's/\/$//g'`
88
dnl This is for stuff that absolutely must end up in pyconfig.h.
89
dnl Please use pyport.h instead, if possible.
95
/* Define the macros needed if on a UnixWare 7.x system. */
96
#if defined(__USLC__) && defined(__SCO_VERSION__)
97
#define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
100
#endif /*Py_PYCONFIG_H*/
103
# We don't use PACKAGE_ variables, and they cause conflicts
104
# with other autoconf-based packages that include Python.h
105
grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
107
mv confdefs.h.new confdefs.h
110
VERSION=PYTHON_VERSION
112
# Version number of Python's own shared library file.
116
# The later defininition of _XOPEN_SOURCE disables certain features
117
# on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
118
AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])
120
# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
121
# certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
123
AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])
125
# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
126
# certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
128
AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])
130
# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
131
# u_int on Irix 5.3. Defining _BSD_TYPES brings it back.
132
AC_DEFINE(_BSD_TYPES, 1, [Define on Irix to enable u_int])
134
# The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
135
# certain features on Mac OS X, so we need _DARWIN_C_SOURCE to re-enable
137
AC_DEFINE(_DARWIN_C_SOURCE, 1, [Define on Darwin to activate all library features])
140
define_xopen_source=yes
142
# Arguments passed to configure.
143
AC_SUBST(CONFIG_ARGS)
144
CONFIG_ARGS="$ac_configure_args"
146
AC_MSG_CHECKING([for --enable-universalsdk])
147
AC_ARG_ENABLE(universalsdk,
148
AS_HELP_STRING([--enable-universalsdk@<:@=SDKDIR@:>@], [Build fat binary against Mac OS X SDK]),
152
# Locate the best usable SDK, see Mac/README.txt for more
154
enableval="`/usr/bin/xcodebuild -version -sdk macosx Path 2>/dev/null`"
155
if ! ( echo $enableval | grep -E '\.sdk' 1>/dev/null )
157
enableval=/Developer/SDKs/MacOSX10.4u.sdk
158
if test ! -d "${enableval}"
171
UNIVERSALSDK=$enableval
172
if test ! -d "${UNIVERSALSDK}"
174
AC_MSG_ERROR([--enable-universalsdk specifies non-existing SDK: ${UNIVERSALSDK}])
183
if test -n "${UNIVERSALSDK}"
185
AC_MSG_RESULT(${UNIVERSALSDK})
189
AC_SUBST(UNIVERSALSDK)
191
AC_SUBST(ARCH_RUN_32BIT)
194
# For backward compatibility reasons we prefer to select '32-bit' if available,
195
# otherwise use 'intel'
196
UNIVERSAL_ARCHS="32-bit"
197
if test "`uname -s`" = "Darwin"
199
if test -n "${UNIVERSALSDK}"
201
if test -z "`/usr/bin/file -L "${UNIVERSALSDK}/usr/lib/libSystem.dylib" | grep ppc`"
203
UNIVERSAL_ARCHS="intel"
208
AC_SUBST(LIPO_32BIT_FLAGS)
209
AC_MSG_CHECKING(for --with-universal-archs)
210
AC_ARG_WITH(universal-archs,
211
AS_HELP_STRING([--with-universal-archs=ARCH], [select architectures for universal build ("32-bit", "64-bit", "3-way", "intel", "intel-32", or "all")]),
213
UNIVERSAL_ARCHS="$withval"
216
if test -n "${UNIVERSALSDK}"
218
AC_MSG_RESULT(${UNIVERSAL_ARCHS})
223
AC_ARG_WITH(framework-name,
224
AS_HELP_STRING([--with-framework-name=FRAMEWORK],
225
[specify an alternate name of the framework built with --enable-framework]),
227
PYTHONFRAMEWORK=${withval}
228
PYTHONFRAMEWORKDIR=${withval}.framework
229
PYTHONFRAMEWORKIDENTIFIER=org.python.`echo $withval | tr '[A-Z]' '[a-z]'`
231
PYTHONFRAMEWORK=Python
232
PYTHONFRAMEWORKDIR=Python.framework
233
PYTHONFRAMEWORKIDENTIFIER=org.python.python
235
dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
236
AC_ARG_ENABLE(framework,
237
AS_HELP_STRING([--enable-framework@<:@=INSTALLDIR@:>@], [Build (MacOSX|Darwin) framework]),
241
enableval=/Library/Frameworks
246
PYTHONFRAMEWORKDIR=no-framework
247
PYTHONFRAMEWORKPREFIX=
248
PYTHONFRAMEWORKINSTALLDIR=
249
FRAMEWORKINSTALLFIRST=
250
FRAMEWORKINSTALLLAST=
251
FRAMEWORKALTINSTALLFIRST=
252
FRAMEWORKALTINSTALLLAST=
254
if test "x${prefix}" = "xNONE"; then
255
FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
257
FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
262
PYTHONFRAMEWORKPREFIX="${enableval}"
263
PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
264
FRAMEWORKINSTALLFIRST="frameworkinstallstructure"
265
FRAMEWORKALTINSTALLFIRST="frameworkinstallstructure "
266
FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools"
267
FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkaltinstallunixtools"
268
FRAMEWORKPYTHONW="frameworkpythonw"
269
FRAMEWORKINSTALLAPPSPREFIX="/Applications"
271
if test "x${prefix}" = "xNONE" ; then
272
FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
275
FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
278
case "${enableval}" in
280
FRAMEWORKINSTALLAPPSPREFIX="/Applications"
281
if test "${prefix}" = "NONE" ; then
283
FRAMEWORKUNIXTOOLSPREFIX="/usr"
288
FRAMEWORKINSTALLAPPSPREFIX="/Applications"
291
*/Library/Frameworks)
292
MDIR="`dirname "${enableval}"`"
293
MDIR="`dirname "${MDIR}"`"
294
FRAMEWORKINSTALLAPPSPREFIX="${MDIR}/Applications"
296
if test "${prefix}" = "NONE"; then
297
# User hasn't specified the
298
# --prefix option, but wants to install
299
# the framework in a non-default location,
300
# ensure that the compatibility links get
301
# installed relative to that prefix as well
302
# instead of in /usr/local.
303
FRAMEWORKUNIXTOOLSPREFIX="${MDIR}"
308
FRAMEWORKINSTALLAPPSPREFIX="/Applications"
312
prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
314
# Add files for Mac specific code to the list of output
316
AC_CONFIG_FILES(Mac/Makefile)
317
AC_CONFIG_FILES(Mac/PythonLauncher/Makefile)
318
AC_CONFIG_FILES(Mac/Resources/framework/Info.plist)
319
AC_CONFIG_FILES(Mac/Resources/app/Info.plist)
323
PYTHONFRAMEWORKDIR=no-framework
324
PYTHONFRAMEWORKPREFIX=
325
PYTHONFRAMEWORKINSTALLDIR=
326
FRAMEWORKINSTALLFIRST=
327
FRAMEWORKINSTALLLAST=
328
FRAMEWORKALTINSTALLFIRST=
329
FRAMEWORKALTINSTALLLAST=
331
if test "x${prefix}" = "xNONE" ; then
332
FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
334
FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
339
AC_SUBST(PYTHONFRAMEWORK)
340
AC_SUBST(PYTHONFRAMEWORKIDENTIFIER)
341
AC_SUBST(PYTHONFRAMEWORKDIR)
342
AC_SUBST(PYTHONFRAMEWORKPREFIX)
343
AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
344
AC_SUBST(FRAMEWORKINSTALLFIRST)
345
AC_SUBST(FRAMEWORKINSTALLLAST)
346
AC_SUBST(FRAMEWORKALTINSTALLFIRST)
347
AC_SUBST(FRAMEWORKALTINSTALLLAST)
348
AC_SUBST(FRAMEWORKPYTHONW)
349
AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX)
350
AC_SUBST(FRAMEWORKINSTALLAPPSPREFIX)
353
## AS_HELP_STRING([--with-dyld],
354
## [Use (OpenStep|Rhapsody) dynamic linker]))
356
# Set name for machine-dependent library files
357
AC_ARG_VAR([MACHDEP], [name for machine-dependent library files])
358
AC_MSG_CHECKING(MACHDEP)
359
if test -z "$MACHDEP"
361
# avoid using uname for cross builds
362
if test "$cross_compiling" = yes; then
363
# ac_sys_system and ac_sys_release are used for setting
364
# a lot of different things including 'define_xopen_source'
365
# in the case statement below.
374
# for now, limit cross builds to known configurations
376
AC_MSG_ERROR([cross build not supported for $host])
380
ac_sys_system=`uname -s`
381
if test "$ac_sys_system" = "AIX" \
382
-o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
383
ac_sys_release=`uname -v`
385
ac_sys_release=`uname -r`
388
ac_md_system=`echo $ac_sys_system |
389
tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
390
ac_md_release=`echo $ac_sys_release |
391
tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
392
MACHDEP="$ac_md_system$ac_md_release"
395
linux*) MACHDEP="linux";;
396
cygwin*) MACHDEP="cygwin";;
397
darwin*) MACHDEP="darwin";;
398
irix646) MACHDEP="irix6";;
399
'') MACHDEP="unknown";;
403
AC_SUBST(_PYTHON_HOST_PLATFORM)
404
if test "$cross_compiling" = yes; then
419
# for now, limit cross builds to known configurations
421
AC_MSG_ERROR([cross build not supported for $host])
423
_PYTHON_HOST_PLATFORM="$MACHDEP${_host_cpu:+-$_host_cpu}"
426
# Some systems cannot stand _XOPEN_SOURCE being defined at all; they
427
# disable features if it is defined, without any means to access these
428
# features as extensions. For these systems, we skip the definition of
429
# _XOPEN_SOURCE. Before adding a system to the list to gain access to
430
# some feature, make sure there is no alternative way to access this
431
# feature. Also, when using wildcards, make sure you have verified the
432
# need for not defining _XOPEN_SOURCE on all systems matching the
433
# wildcard, and that the wildcard does not include future systems
434
# (which may remove their limitations).
435
dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
436
case $ac_sys_system/$ac_sys_release in
437
# On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
438
# even though select is a POSIX function. Reported by J. Ribbens.
439
# Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
440
# In addition, Stefan Krah confirms that issue #1244610 exists through
441
# OpenBSD 4.6, but is fixed in 4.7.
442
OpenBSD/2.* | OpenBSD/3.* | OpenBSD/4.@<:@0123456@:>@)
443
define_xopen_source=no
444
# OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
445
# also defined. This can be overridden by defining _BSD_SOURCE
446
# As this has a different meaning on Linux, only define it on OpenBSD
447
AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
450
# OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
451
# also defined. This can be overridden by defining _BSD_SOURCE
452
# As this has a different meaning on Linux, only define it on OpenBSD
453
AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
455
# Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
456
# _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
458
NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6@<:@A-S@:>@)
459
define_xopen_source=no;;
460
# From the perspective of Solaris, _XOPEN_SOURCE is not so much a
461
# request to enable features supported by the standard as a request
462
# to disable features not supported by the standard. The best way
463
# for Python to use Solaris is simply to leave _XOPEN_SOURCE out
464
# entirely and define __EXTENSIONS__ instead.
466
define_xopen_source=no;;
467
# On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
468
# but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
469
# Reconfirmed for 7.1.4 by Martin v. Loewis.
470
OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
471
define_xopen_source=no;;
472
# On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
473
# but used in struct sockaddr.sa_family. Reported by Tim Rice.
475
define_xopen_source=no;;
476
# On FreeBSD 4, the math functions C89 does not cover are never defined
477
# with _XOPEN_SOURCE and __BSD_VISIBLE does not re-enable them.
479
define_xopen_source=no;;
480
# On MacOS X 10.2, a bug in ncurses.h means that it craps out if
481
# _XOPEN_EXTENDED_SOURCE is defined. Apparently, this is fixed in 10.3, which
482
# identifies itself as Darwin/7.*
483
# On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
484
# disables platform specific features beyond repair.
485
# On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
486
# has no effect, don't bother defining them
487
Darwin/@<:@6789@:>@.*)
488
define_xopen_source=no;;
489
Darwin/1@<:@0-9@:>@.*)
490
define_xopen_source=no;;
491
# On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
492
# used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
493
# or has another value. By not (re)defining it, the defaults come in place.
495
define_xopen_source=no;;
497
if test `uname -r` -eq 1; then
498
define_xopen_source=no
501
# On QNX 6.3.2, defining _XOPEN_SOURCE prevents netdb.h from
502
# defining NI_NUMERICHOST.
504
define_xopen_source=no
509
if test $define_xopen_source = yes
511
# X/Open 7, incorporating POSIX.1-2008
512
AC_DEFINE(_XOPEN_SOURCE, 700,
513
Define to the level of X/Open that your system supports)
515
# On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
516
# definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
517
# several APIs are not declared. Since this is also needed in some
518
# cases for HP-UX, we define it globally.
519
AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
520
Define to activate Unix95-and-earlier features)
522
AC_DEFINE(_POSIX_C_SOURCE, 200809L, Define to activate features from IEEE Stds 1003.1-2008)
526
# SGI compilers allow the specification of the both the ABI and the
527
# ISA on the command line. Depending on the values of these switches,
528
# different and often incompatable code will be generated.
530
# The SGI_ABI variable can be used to modify the CC and LDFLAGS and
531
# thus supply support for various ABI/ISA combinations. The MACHDEP
532
# variable is also adjusted.
535
if test ! -z "$SGI_ABI"
538
LDFLAGS="$SGI_ABI $LDFLAGS"
539
MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
541
AC_MSG_RESULT($MACHDEP)
543
# Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
544
# it may influence the way we can build extensions, so distutils
546
AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
547
AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
548
CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
549
EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
551
# checks for alternative programs
553
# compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
554
# for debug/optimization stuff. BASECFLAGS is for flags that are required
555
# just to get things to compile and link. Users are free to override OPT
556
# when running configure or make. The build should not break if they do.
557
# BASECFLAGS should generally not be messed with, however.
559
# XXX shouldn't some/most/all of this code be merged with the stuff later
560
# on that fiddles with OPT and BASECFLAGS?
561
AC_MSG_CHECKING(for --without-gcc)
563
AS_HELP_STRING([--without-gcc], [never use gcc]),
571
without_gcc=$withval;;
573
case $ac_sys_system in
574
AIX*) CC=${CC:-xlc_r}
578
AC_MSG_RESULT($without_gcc)
580
# If the user switches compilers, we can't believe the cache
581
if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
583
AC_MSG_ERROR([cached CC is different -- throw away $cache_file
584
(it is also a good idea to do 'make clean' before compiling)])
587
# Don't let AC_PROG_CC set the default CFLAGS. It normally sets -g -O2
588
# when the compiler supports them, but we don't always want -O2, and
590
if test -z "$CFLAGS"; then
594
if test "$ac_sys_system" = "Darwin"
596
# Compiler selection on MacOSX is more complicated than
597
# AC_PROG_CC can handle, see Mac/README.txt for more
603
as_save_IFS=$IFS; IFS=:
607
if test -x $as_dir/gcc; then
608
if test -z "${found_gcc}"; then
609
found_gcc=$as_dir/gcc
612
if test -x $as_dir/clang; then
613
if test -z "${found_clang}"; then
614
found_clang=$as_dir/clang
620
if test -n "$found_gcc" -a -n "$found_clang"
622
if test -n "`"$found_gcc" --version | grep llvm-gcc`"
624
AC_MSG_NOTICE([Detected llvm-gcc, falling back to clang])
630
elif test -z "$found_gcc" -a -n "$found_clang"
632
AC_MSG_NOTICE([No GCC found, use CLANG])
636
elif test -z "$found_gcc" -a -z "$found_clang"
638
found_clang=`/usr/bin/xcrun -find clang 2>/dev/null`
639
if test -n "${found_clang}"
641
AC_MSG_NOTICE([Using clang from Xcode.app])
643
CXX="`/usr/bin/xcrun -find clang++`"
645
# else: use default behaviour
654
AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
655
AC_ARG_WITH(cxx_main,
656
AS_HELP_STRING([--with-cxx-main=<compiler>],
657
[compile main() and link python executable with C++ compiler]),
663
yes) with_cxx_main=yes
675
AC_MSG_RESULT($with_cxx_main)
681
gcc) AC_PATH_TOOL(CXX, [g++], [g++], [notfound]) ;;
682
cc) AC_PATH_TOOL(CXX, [c++], [c++], [notfound]) ;;
683
clang|*/clang) AC_PATH_TOOL(CXX, [clang++], [clang++], [notfound]) ;;
685
if test "$CXX" = "notfound"
692
AC_CHECK_TOOLS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
693
if test "$CXX" = "notfound"
698
if test "$preset_cxx" != "$CXX"
702
By default, distutils will build C++ extension modules with "$CXX".
703
If this is not intended, then set CXX on the configure command line.
708
AC_MSG_CHECKING([for -Wl,--no-as-needed])
709
save_LDFLAGS="$LDFLAGS"
710
LDFLAGS="$LDFLAGS -Wl,--no-as-needed"
711
AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
712
[NO_AS_NEEDED="-Wl,--no-as-needed"
713
AC_MSG_RESULT([yes])],
715
AC_MSG_RESULT([no])])
716
LDFLAGS="$save_LDFLAGS"
717
AC_SUBST(NO_AS_NEEDED)
720
# checks for UNIX variants that set C preprocessor variables
721
AC_USE_SYSTEM_EXTENSIONS
723
# Check for unsupported systems
724
case $ac_sys_system/$ac_sys_release in
726
echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
727
echo See README for details.
732
AC_MSG_CHECKING(for --with-suffix)
734
AS_HELP_STRING([--with-suffix=.exe], [set executable suffix]),
741
AC_MSG_RESULT($EXEEXT)
743
# Test whether we're running on a non-case-sensitive system, in which
744
# case we give a warning if no ext is given
745
AC_SUBST(BUILDEXEEXT)
746
AC_MSG_CHECKING(for case-insensitive build directory)
747
if test ! -d CaseSensitiveTestDir; then
748
mkdir CaseSensitiveTestDir
751
if test -d casesensitivetestdir
759
rmdir CaseSensitiveTestDir
764
gcc) CC="$CC -D_HAVE_BSDI";;
768
case $ac_sys_system in
771
cc|*/cc) CC="$CC -Ae";;
775
MULTIARCH=$($CC --print-multiarch 2>/dev/null)
780
AC_MSG_CHECKING(LIBRARY)
781
if test -z "$LIBRARY"
783
LIBRARY='libpython$(VERSION)$(ABIFLAGS).a'
785
AC_MSG_RESULT($LIBRARY)
787
# LDLIBRARY is the name of the library to link against (as opposed to the
788
# name of the library into which to insert object files). BLDLIBRARY is also
789
# the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
790
# is blank as the main program is not linked directly against LDLIBRARY.
791
# LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
792
# systems without shared libraries, LDLIBRARY is the same as LIBRARY
793
# (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
794
# DLLLIBRARY is the shared (i.e., DLL) library.
796
# RUNSHARED is used to run shared python without installed libraries
798
# INSTSONAME is the name of the shared library that will be use to install
799
# on the system - some systems like version suffix, others don't
801
# LDVERSION is the shared library version number, normally the Python version
802
# with the ABI build flags appended.
807
AC_SUBST(LDLIBRARYDIR)
812
BLDLIBRARY='$(LDLIBRARY)'
813
INSTSONAME='$(LDLIBRARY)'
819
# LINKCC is the command that links the python executable -- default is $(CC).
820
# If CXX is set, and if it is needed to link a main function that was
821
# compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
822
# python might then depend on the C++ runtime
823
# This is altered for AIX in order to build the export list before
826
AC_MSG_CHECKING(LINKCC)
829
LINKCC='$(PURIFY) $(MAINCC)'
830
case $ac_sys_system in
833
if test $ac_sys_release -ge 5 -o \
834
$ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
837
LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
839
# qcc must be used because the other compilers do not
844
AC_MSG_RESULT($LINKCC)
846
# GNULD is set to "yes" if the GNU linker is used. If this goes wrong
847
# make sure we default having it set to "no": this is used by
848
# distutils.unixccompiler to know if it should add --enable-new-dtags
849
# to linker command lines, and failing to detect GNU ld simply results
850
# in the same bahaviour as before.
852
AC_MSG_CHECKING(for GNU ld)
854
if test "$GCC" = yes; then
855
ac_prog=`$CC -print-prog-name=ld`
857
case `"$ac_prog" -V 2>&1 < /dev/null` in
863
AC_MSG_RESULT($GNULD)
866
if test "$ac_cv_c_inline" != no ; then
867
AC_DEFINE(USE_INLINE, 1, [Define to use the C99 inline keyword.])
872
AC_MSG_CHECKING(for --enable-shared)
873
AC_ARG_ENABLE(shared,
874
AS_HELP_STRING([--enable-shared], [disable/enable building shared python library]))
876
if test -z "$enable_shared"
878
case $ac_sys_system in
880
enable_shared="yes";;
885
AC_MSG_RESULT($enable_shared)
887
AC_MSG_CHECKING(for --enable-profiling)
888
AC_ARG_ENABLE(profiling,
889
AS_HELP_STRING([--enable-profiling], [enable C-level code profiling]))
890
if test "x$enable_profiling" = xyes; then
893
AC_LINK_IFELSE([AC_LANG_SOURCE([[int main() { return 0; }]])],
895
[enable_profiling=no])
900
AC_MSG_RESULT($enable_profiling)
902
if test "x$enable_profiling" = xyes; then
903
BASECFLAGS="-pg $BASECFLAGS"
904
LDFLAGS="-pg $LDFLAGS"
907
AC_MSG_CHECKING(LDLIBRARY)
909
# MacOSX framework builds need more magic. LDLIBRARY is the dynamic
910
# library that we build, but we do not want to link against it (we
911
# will find it with a -framework option). For this reason there is an
912
# extra variable BLDLIBRARY against which Python and the extension
913
# modules are linked, BLDLIBRARY. This is normally the same as
914
# LDLIBRARY, but empty for MacOSX framework builds.
915
if test "$enable_framework"
917
LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
918
RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
921
BLDLIBRARY='$(LDLIBRARY)'
924
# Other platforms follow
925
if test $enable_shared = "yes"; then
927
AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
928
case $ac_sys_system in
930
LDLIBRARY='libpython$(LDVERSION).dll.a'
931
DLLLIBRARY='libpython$(LDVERSION).dll'
934
LDLIBRARY='libpython$(LDVERSION).so'
935
BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(LDVERSION)'
936
RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
937
INSTSONAME="$LDLIBRARY".$SOVERSION
938
if test "$with_pydebug" != yes
940
PY3LIBRARY=libpython3.so
943
Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*|OpenBSD*)
944
LDLIBRARY='libpython$(LDVERSION).so'
945
BLDLIBRARY='-L. -lpython$(LDVERSION)'
946
RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
947
case $ac_sys_system in
949
SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
952
INSTSONAME="$LDLIBRARY".$SOVERSION
953
if test "$with_pydebug" != yes
955
PY3LIBRARY=libpython3.so
961
LDLIBRARY='libpython$(LDVERSION).so'
964
LDLIBRARY='libpython$(LDVERSION).sl'
967
BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(LDVERSION)'
968
RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
971
LDLIBRARY='libpython$(LDVERSION).dylib'
972
BLDLIBRARY='-L. -lpython$(LDVERSION)'
973
RUNSHARED='DYLD_LIBRARY_PATH=`pwd`:${DYLD_LIBRARY_PATH}'
976
LDLIBRARY='libpython$(LDVERSION).so'
977
RUNSHARED=LIBPATH=`pwd`:${LIBPATH}
981
else # shared is disabled
983
case $ac_sys_system in
985
BLDLIBRARY='$(LIBRARY)'
986
LDLIBRARY='libpython$(LDVERSION).dll.a'
991
if test "$cross_compiling" = yes; then
995
AC_MSG_RESULT($LDLIBRARY)
999
AC_CHECK_TOOLS(AR, ar aal, ar)
1001
# tweak ARFLAGS only if the user didn't set it on the command line
1003
if test -z "$ARFLAGS"
1008
AC_CHECK_TOOLS([READELF], [readelf], [:])
1009
if test "$cross_compiling" = yes; then
1012
AC_MSG_ERROR([readelf for the host is required for cross builds])
1019
AC_CHECK_PROGS(PYTHON, python$PACKAGE_VERSION python3 python, not-found)
1020
if test "$PYTHON" = not-found; then
1021
ASDLGEN="@echo python: $PYTHON! cannot run \$(srcdir)/Parser/asdl_c.py #"
1029
# install -d does not work on BSDI or HP-UX
1030
if test -z "$INSTALL"
1032
INSTALL="${srcdir}/install-sh -c"
1038
# Not every filesystem supports hard links
1040
if test -z "$LN" ; then
1041
case $ac_sys_system in
1042
CYGWIN*) LN="ln -s";;
1047
# For calculating the .so ABI tag.
1051
# Check for --with-pydebug
1052
AC_MSG_CHECKING(for --with-pydebug)
1053
AC_ARG_WITH(pydebug,
1054
AS_HELP_STRING([--with-pydebug], [build with Py_DEBUG defined]),
1056
if test "$withval" != no
1058
AC_DEFINE(Py_DEBUG, 1,
1059
[Define if you want to build an interpreter with many run-time checks.])
1062
ABIFLAGS="${ABIFLAGS}d"
1063
else AC_MSG_RESULT(no); Py_DEBUG='false'
1065
[AC_MSG_RESULT(no)])
1067
# XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
1068
# merged with this chunk of code?
1070
# Optimizer/debugger flags
1071
# ------------------------
1072
# (The following bit of code is complicated enough - please keep things
1073
# indented properly. Just pretend you're editing Python code. ;-)
1075
# There are two parallel sets of case statements below, one that checks to
1076
# see if OPT was set and one that does BASECFLAGS setting based upon
1077
# compiler and platform. BASECFLAGS tweaks need to be made even if the
1080
# tweak OPT based on compiler and platform, only if the user didn't set
1081
# it on the command line
1083
if test "${OPT-unset}" = "unset"
1087
if test "$CC" != 'g++' ; then
1088
STRICT_PROTO="-Wstrict-prototypes"
1090
# For gcc 4.x we need to use -fwrapv so lets check if its supported
1091
if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
1095
# Clang also needs -fwrapv
1097
*clang*) WRAP="-fwrapv"
1101
case $ac_cv_prog_cc_g in
1103
if test "$Py_DEBUG" = 'true' ; then
1104
# Optimization messes up debuggers, so turn it off for
1106
OPT="-g -O0 -Wall $STRICT_PROTO"
1108
OPT="-g $WRAP -O3 -Wall $STRICT_PROTO"
1112
OPT="-O3 -Wall $STRICT_PROTO"
1115
case $ac_sys_system in
1116
SCO_SV*) OPT="$OPT -m486 -DSCO5"
1127
AC_SUBST(BASECFLAGS)
1129
# The -arch flags for universal builds on OSX
1130
UNIVERSAL_ARCH_FLAGS=
1131
AC_SUBST(UNIVERSAL_ARCH_FLAGS)
1133
# tweak BASECFLAGS based on compiler and platform
1136
# Python doesn't violate C99 aliasing rules, but older versions of
1137
# GCC produce warnings for legal Python code. Enable
1138
# -fno-strict-aliasing on versions of GCC that support but produce
1139
# warnings. See Issue3326
1140
AC_MSG_CHECKING(whether $CC accepts and needs -fno-strict-aliasing)
1142
CC="$CC -fno-strict-aliasing"
1143
save_CFLAGS="$CFLAGS"
1144
AC_CACHE_VAL(ac_cv_no_strict_aliasing,
1147
AC_LANG_PROGRAM([[]], [[]])
1149
CC="$ac_save_cc -fstrict-aliasing"
1150
CFLAGS="$CFLAGS -Werror -Wstrict-aliasing"
1153
AC_LANG_PROGRAM([[void f(int **x) {}]],
1154
[[double *x; f((int **) &x);]])
1156
ac_cv_no_strict_aliasing=no
1158
ac_cv_no_strict_aliasing=yes
1161
ac_cv_no_strict_aliasing=no
1163
CFLAGS="$save_CFLAGS"
1165
AC_MSG_RESULT($ac_cv_no_strict_aliasing)
1166
if test $ac_cv_no_strict_aliasing = yes
1168
BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
1171
AC_MSG_CHECKING(if we can turn off $CC unused result warning)
1173
CC="$CC -Wunused-result -Werror"
1174
save_CFLAGS="$CFLAGS"
1175
AC_CACHE_VAL(ac_cv_disable_unused_result_warning,
1178
AC_LANG_PROGRAM([[]], [[]])
1180
ac_cv_disable_unused_result_warning=yes
1182
ac_cv_disable_unused_result_warning=no
1184
CFLAGS="$save_CFLAGS"
1186
AC_MSG_RESULT($ac_cv_disable_unused_result_warning)
1188
if test $ac_cv_disable_unused_result_warning = yes
1190
BASECFLAGS="$BASECFLAGS -Wno-unused-result"
1193
AC_MSG_CHECKING(for -Werror=declaration-after-statement)
1195
CC="$CC -Werror=declaration-after-statement"
1196
save_CFLAGS="$CFLAGS"
1197
AC_CACHE_VAL(ac_cv_declaration_after_statement_warning,
1200
AC_LANG_PROGRAM([[]], [[]])
1202
ac_cv_declaration_after_statement_warning=yes
1204
ac_cv_declaration_after_statement_warning=no
1206
CFLAGS="$save_CFLAGS"
1208
AC_MSG_RESULT($ac_cv_declaration_after_statement_warning)
1210
if test $ac_cv_declaration_after_statement_warning = yes
1212
BASECFLAGS="$BASECFLAGS -Werror=declaration-after-statement"
1215
# if using gcc on alpha, use -mieee to get (near) full IEEE 754
1216
# support. Without this, treatment of subnormals doesn't follow
1220
BASECFLAGS="$BASECFLAGS -mieee"
1224
case $ac_sys_system in
1226
BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
1229
# is there any other compiler on Darwin besides gcc?
1231
# -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
1232
# used to be here, but non-Apple gcc doesn't accept them.
1233
if test "${CC}" = gcc
1235
AC_MSG_CHECKING(which compiler should be used)
1236
case "${UNIVERSALSDK}" in
1238
# Build using 10.4 SDK, force usage of gcc when the
1239
# compiler is gcc, otherwise the user will get very
1240
# confusing error messages when building on OSX 10.6
1248
if test "${enable_universalsdk}"
1250
case "$UNIVERSAL_ARCHS" in
1252
UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386"
1257
UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64"
1259
ARCH_RUN_32BIT="true"
1262
UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64"
1263
LIPO_32BIT_FLAGS="-extract ppc7400 -extract i386"
1264
ARCH_RUN_32BIT="/usr/bin/arch -i386 -ppc"
1267
UNIVERSAL_ARCH_FLAGS="-arch i386 -arch x86_64"
1268
LIPO_32BIT_FLAGS="-extract i386"
1269
ARCH_RUN_32BIT="/usr/bin/arch -i386"
1272
UNIVERSAL_ARCH_FLAGS="-arch i386"
1277
UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch x86_64"
1278
LIPO_32BIT_FLAGS="-extract ppc7400 -extract i386"
1279
ARCH_RUN_32BIT="/usr/bin/arch -i386 -ppc"
1282
AC_MSG_ERROR([proper usage is --with-universal-arch=32-bit|64-bit|all|intel|3-way])
1286
CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
1287
LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1288
if test "${UNIVERSALSDK}" != "/"
1290
CPPFLAGS="-isysroot ${UNIVERSALSDK} ${CPPFLAGS}"
1294
# Calculate an appropriate deployment target for this build:
1295
# The deployment target value is used explicitly to enable certain
1296
# features are enabled (such as builtin libedit support for readline)
1297
# through the use of Apple's Availabiliy Macros and is used as a
1298
# component of the string returned by distutils.get_platform().
1300
# Use the value from:
1301
# 1. the MACOSX_DEPLOYMENT_TARGET environment variable if specified
1302
# 2. the operating system version of the build machine if >= 10.6
1303
# 3. If running on OS X 10.3 through 10.5, use the legacy tests
1304
# below to pick either 10.3, 10.4, or 10.5 as the target.
1305
# 4. If we are running on OS X 10.2 or earlier, good luck!
1307
AC_MSG_CHECKING(which MACOSX_DEPLOYMENT_TARGET to use)
1308
cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
1309
if test ${cur_target} '>' 10.2 && \
1310
test ${cur_target} '<' 10.6
1313
if test ${enable_universalsdk}
1315
case "$UNIVERSAL_ARCHS" in
1316
all|3-way|intel|64-bit)
1317
# These configurations were first supported in 10.5
1322
if test `/usr/bin/arch` = "i386"
1324
# 10.4 was the first release to support Intel archs
1329
CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1331
# Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
1332
# environment with a value that is the same as what we'll use
1333
# in the Makefile to ensure that we'll get the same compiler
1334
# environment during configure and build time.
1335
MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
1336
export MACOSX_DEPLOYMENT_TARGET
1337
EXPORT_MACOSX_DEPLOYMENT_TARGET=''
1338
AC_MSG_RESULT($MACOSX_DEPLOYMENT_TARGET)
1340
# end of Darwin* tests
1346
case $ac_sys_system in
1347
OpenUNIX*|UnixWare*)
1348
BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
1351
BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
1357
if test "$Py_DEBUG" = 'true'; then
1363
if test "$ac_arch_flags"
1365
BASECFLAGS="$BASECFLAGS $ac_arch_flags"
1368
# On some compilers, pthreads are available without further options
1369
# (e.g. MacOS X). On some of these systems, the compiler will not
1370
# complain if unaccepted options are passed (e.g. gcc on Mac OS X).
1371
# So we have to see first whether pthreads are available without
1372
# options before we can check whether -Kpthread improves anything.
1373
AC_MSG_CHECKING(whether pthreads are available without options)
1374
AC_CACHE_VAL(ac_cv_pthread_is_default,
1375
[AC_RUN_IFELSE([AC_LANG_SOURCE([[
1377
#include <pthread.h>
1379
void* routine(void* p){return NULL;}
1383
if(pthread_create(&p,NULL,routine,NULL)!=0)
1385
(void)pthread_detach(p);
1389
ac_cv_pthread_is_default=yes
1392
],[ac_cv_pthread_is_default=no],[ac_cv_pthread_is_default=no])
1394
AC_MSG_RESULT($ac_cv_pthread_is_default)
1397
if test $ac_cv_pthread_is_default = yes
1401
# -Kpthread, if available, provides the right #defines
1402
# and linker options to make pthread_create available
1403
# Some compilers won't report that they do not support -Kpthread,
1404
# so we need to run a program to see whether it really made the
1405
# function available.
1406
AC_MSG_CHECKING(whether $CC accepts -Kpthread)
1407
AC_CACHE_VAL(ac_cv_kpthread,
1410
AC_RUN_IFELSE([AC_LANG_SOURCE([[
1412
#include <pthread.h>
1414
void* routine(void* p){return NULL;}
1418
if(pthread_create(&p,NULL,routine,NULL)!=0)
1420
(void)pthread_detach(p);
1423
]])],[ac_cv_kpthread=yes],[ac_cv_kpthread=no],[ac_cv_kpthread=no])
1425
AC_MSG_RESULT($ac_cv_kpthread)
1428
if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
1430
# -Kthread, if available, provides the right #defines
1431
# and linker options to make pthread_create available
1432
# Some compilers won't report that they do not support -Kthread,
1433
# so we need to run a program to see whether it really made the
1434
# function available.
1435
AC_MSG_CHECKING(whether $CC accepts -Kthread)
1436
AC_CACHE_VAL(ac_cv_kthread,
1439
AC_RUN_IFELSE([AC_LANG_SOURCE([[
1441
#include <pthread.h>
1443
void* routine(void* p){return NULL;}
1447
if(pthread_create(&p,NULL,routine,NULL)!=0)
1449
(void)pthread_detach(p);
1452
]])],[ac_cv_kthread=yes],[ac_cv_kthread=no],[ac_cv_kthread=no])
1454
AC_MSG_RESULT($ac_cv_kthread)
1457
if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
1459
# -pthread, if available, provides the right #defines
1460
# and linker options to make pthread_create available
1461
# Some compilers won't report that they do not support -pthread,
1462
# so we need to run a program to see whether it really made the
1463
# function available.
1464
AC_MSG_CHECKING(whether $CC accepts -pthread)
1465
AC_CACHE_VAL(ac_cv_pthread,
1468
AC_RUN_IFELSE([AC_LANG_SOURCE([[
1470
#include <pthread.h>
1472
void* routine(void* p){return NULL;}
1476
if(pthread_create(&p,NULL,routine,NULL)!=0)
1478
(void)pthread_detach(p);
1481
]])],[ac_cv_pthread=yes],[ac_cv_pthread=no],[ac_cv_pthread=no])
1483
AC_MSG_RESULT($ac_cv_pthread)
1486
# If we have set a CC compiler flag for thread support then
1487
# check if it works for CXX, too.
1491
AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1494
if test "$ac_cv_kpthread" = "yes"
1496
CXX="$CXX -Kpthread"
1497
ac_cv_cxx_thread=yes
1498
elif test "$ac_cv_kthread" = "yes"
1501
ac_cv_cxx_thread=yes
1502
elif test "$ac_cv_pthread" = "yes"
1505
ac_cv_cxx_thread=yes
1508
if test $ac_cv_cxx_thread = yes
1510
echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1511
$CXX -c conftest.$ac_ext 2>&5
1512
if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1513
&& test -s conftest$ac_exeext && ./conftest$ac_exeext
1515
ac_cv_cxx_thread=yes
1521
AC_MSG_RESULT($ac_cv_cxx_thread)
1525
dnl # check for ANSI or K&R ("traditional") preprocessor
1526
dnl AC_MSG_CHECKING(for C preprocessor type)
1527
dnl AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1528
dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1530
dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1531
dnl ]], [[;]])],[cpp_type=ansi],[AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional])
1532
dnl AC_MSG_RESULT($cpp_type)
1534
# checks for header files
1536
ac_save_cppflags="$CPPFLAGS"
1537
CPPFLAGS="$CPPFLAGS -I/usr/include/ncursesw"
1538
AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1540
ieeefp.h io.h langinfo.h libintl.h ncurses.h process.h pthread.h \
1541
sched.h shadow.h signal.h stdint.h stropts.h termios.h \
1543
poll.h sys/devpoll.h sys/epoll.h sys/poll.h \
1544
sys/audioio.h sys/xattr.h sys/bsdtty.h sys/event.h sys/file.h sys/ioctl.h \
1545
sys/kern_control.h sys/loadavg.h sys/lock.h sys/mkdev.h sys/modem.h \
1546
sys/param.h sys/select.h sys/sendfile.h sys/socket.h sys/statvfs.h \
1547
sys/stat.h sys/syscall.h sys/sys_domain.h sys/termio.h sys/time.h \
1548
sys/times.h sys/types.h sys/uio.h sys/un.h sys/utsname.h sys/wait.h pty.h \
1549
libutil.h sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1550
bluetooth/bluetooth.h linux/tipc.h spawn.h util.h alloca.h endian.h \
1552
CPPFLAGS=$ac_save_cppflags
1556
# On Darwin (OS X) net/if.h requires sys/socket.h to be imported first.
1557
AC_CHECK_HEADERS([net/if.h], [], [],
1560
# include <stdlib.h>
1561
# include <stddef.h>
1563
# ifdef HAVE_STDLIB_H
1564
# include <stdlib.h>
1567
#ifdef HAVE_SYS_SOCKET_H
1568
# include <sys/socket.h>
1573
# On Solaris, term.h requires curses.h
1574
AC_CHECK_HEADERS(term.h,,,[
1575
#ifdef HAVE_CURSES_H
1580
# On Linux, netlink.h requires asm/types.h
1581
AC_CHECK_HEADERS(linux/netlink.h,,,[
1582
#ifdef HAVE_ASM_TYPES_H
1583
#include <asm/types.h>
1585
#ifdef HAVE_SYS_SOCKET_H
1586
#include <sys/socket.h>
1590
# On Linux, can.h and can/raw.h require sys/socket.h
1591
AC_CHECK_HEADERS(linux/can.h linux/can/raw.h linux/can/bcm.h,,,[
1592
#ifdef HAVE_SYS_SOCKET_H
1593
#include <sys/socket.h>
1597
# checks for typedefs
1599
AC_MSG_CHECKING(for clock_t in time.h)
1600
AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1601
AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1603
AC_MSG_RESULT($was_it_defined)
1605
AC_MSG_CHECKING(for makedev)
1606
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
1607
#if defined(MAJOR_IN_MKDEV)
1608
#include <sys/mkdev.h>
1609
#elif defined(MAJOR_IN_SYSMACROS)
1610
#include <sys/sysmacros.h>
1612
#include <sys/types.h>
1616
],[ac_cv_has_makedev=yes],[ac_cv_has_makedev=no])
1617
AC_MSG_RESULT($ac_cv_has_makedev)
1618
if test "$ac_cv_has_makedev" = "yes"; then
1619
AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1623
AC_MSG_CHECKING(for le64toh)
1624
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
1625
#ifdef HAVE_ENDIAN_H
1627
#elif defined(HAVE_SYS_ENDIAN_H)
1628
#include <sys/endian.h>
1632
],[ac_cv_has_le64toh=yes],[ac_cv_has_le64toh=no])
1633
AC_MSG_RESULT($ac_cv_has_le64toh)
1634
if test "$ac_cv_has_le64toh" = "yes"; then
1635
AC_DEFINE(HAVE_HTOLE64, 1, [Define this if you have le64toh()])
1638
# Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1639
# the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1640
# defined, but the compiler does not support pragma redefine_extname,
1641
# and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1642
# structures (such as rlimit64) without declaring them. As a
1643
# work-around, disable LFS on such configurations
1646
AC_MSG_CHECKING(Solaris LFS bug)
1647
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1648
#define _LARGEFILE_SOURCE 1
1649
#define _FILE_OFFSET_BITS 64
1650
#include <sys/resource.h>
1651
]], [[struct rlimit foo;]])],[sol_lfs_bug=no],[sol_lfs_bug=yes])
1652
AC_MSG_RESULT($sol_lfs_bug)
1653
if test "$sol_lfs_bug" = "yes"; then
1657
if test "$use_lfs" = "yes"; then
1658
# Two defines needed to enable largefile support on various platforms
1659
# These may affect some typedefs
1660
case $ac_sys_system/$ac_sys_release in
1662
AC_DEFINE(_LARGE_FILES, 1,
1663
[This must be defined on AIX systems to enable large file support.])
1666
AC_DEFINE(_LARGEFILE_SOURCE, 1,
1667
[This must be defined on some systems to enable large file support.])
1668
AC_DEFINE(_FILE_OFFSET_BITS, 64,
1669
[This must be set to 64 on some systems to enable large file support.])
1672
# Add some code to confdefs.h so that the test for off_t works on SCO
1673
cat >> confdefs.h <<\EOF
1679
# Type availability checks
1683
AC_DEFINE_UNQUOTED([RETSIGTYPE],[void],[assume C89 semantics that RETSIGTYPE is always void])
1687
# There are two separate checks for each of the exact-width integer types we
1688
# need. First we check whether the type is available using the usual
1689
# AC_CHECK_TYPE macro with the default includes (which includes <inttypes.h>
1690
# and <stdint.h> where available). We then also use the special type checks of
1691
# the form AC_TYPE_UINT32_T, which in the case that uint32_t is not available
1692
# directly, #define's uint32_t to be a suitable type.
1694
AC_CHECK_TYPE(uint32_t,
1695
AC_DEFINE(HAVE_UINT32_T, 1, [Define if your compiler provides uint32_t.]),,)
1698
AC_CHECK_TYPE(uint64_t,
1699
AC_DEFINE(HAVE_UINT64_T, 1, [Define if your compiler provides uint64_t.]),,)
1702
AC_CHECK_TYPE(int32_t,
1703
AC_DEFINE(HAVE_INT32_T, 1, [Define if your compiler provides int32_t.]),,)
1706
AC_CHECK_TYPE(int64_t,
1707
AC_DEFINE(HAVE_INT64_T, 1, [Define if your compiler provides int64_t.]),,)
1710
AC_CHECK_TYPE(ssize_t,
1711
AC_DEFINE(HAVE_SSIZE_T, 1, [Define if your compiler provides ssize_t]),,)
1712
AC_CHECK_TYPE(__uint128_t,
1713
AC_DEFINE(HAVE_GCC_UINT128_T, 1, [Define if your compiler provides __uint128_t]),,)
1715
# Sizes of various common basic types
1716
# ANSI C requires sizeof(char) == 1, so no need to check it
1717
AC_CHECK_SIZEOF(int, 4)
1718
AC_CHECK_SIZEOF(long, 4)
1719
AC_CHECK_SIZEOF(void *, 4)
1720
AC_CHECK_SIZEOF(short, 2)
1721
AC_CHECK_SIZEOF(float, 4)
1722
AC_CHECK_SIZEOF(double, 8)
1723
AC_CHECK_SIZEOF(fpos_t, 4)
1724
AC_CHECK_SIZEOF(size_t, 4)
1725
AC_CHECK_SIZEOF(pid_t, 4)
1727
AC_MSG_CHECKING(for long long support)
1729
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[long long x; x = (long long)0;]])],[
1730
AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1733
AC_MSG_RESULT($have_long_long)
1734
if test "$have_long_long" = yes ; then
1735
AC_CHECK_SIZEOF(long long, 8)
1738
AC_MSG_CHECKING(for long double support)
1740
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[long double x; x = (long double)0;]])],[
1741
AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define this if you have the type long double.])
1742
have_long_double=yes
1744
AC_MSG_RESULT($have_long_double)
1745
if test "$have_long_double" = yes ; then
1746
AC_CHECK_SIZEOF(long double, 16)
1750
AC_MSG_CHECKING(for _Bool support)
1752
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[_Bool x; x = (_Bool)0;]])],[
1753
AC_DEFINE(HAVE_C99_BOOL, 1, [Define this if you have the type _Bool.])
1756
AC_MSG_RESULT($have_c99_bool)
1757
if test "$have_c99_bool" = yes ; then
1758
AC_CHECK_SIZEOF(_Bool, 1)
1761
AC_CHECK_TYPES(uintptr_t,
1762
[AC_CHECK_SIZEOF(uintptr_t, 4)],
1763
[], [#ifdef HAVE_STDINT_H
1766
#ifdef HAVE_INTTYPES_H
1767
#include <inttypes.h>
1770
AC_CHECK_SIZEOF(off_t, [], [
1771
#ifdef HAVE_SYS_TYPES_H
1772
#include <sys/types.h>
1776
AC_MSG_CHECKING(whether to enable large file support)
1777
if test "$have_long_long" = yes
1779
if test "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1780
"$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1781
AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1782
[Defined to enable large file support when an off_t is bigger than a long
1783
and long long is available and at least as big as an off_t. You may need
1784
to add some flags for configuration and compilation to enable this mode.
1785
(For Solaris and Linux, the necessary defines are already defined.)])
1794
AC_CHECK_SIZEOF(time_t, [], [
1795
#ifdef HAVE_SYS_TYPES_H
1796
#include <sys/types.h>
1803
# if have pthread_t then define SIZEOF_PTHREAD_T
1805
if test "$ac_cv_kpthread" = "yes"
1806
then CC="$CC -Kpthread"
1807
elif test "$ac_cv_kthread" = "yes"
1808
then CC="$CC -Kthread"
1809
elif test "$ac_cv_pthread" = "yes"
1810
then CC="$CC -pthread"
1813
AC_MSG_CHECKING(for pthread_t)
1816
AC_LANG_PROGRAM([[#include <pthread.h>]], [[pthread_t x; x = *(pthread_t*)0;]])
1817
],[have_pthread_t=yes],[])
1818
AC_MSG_RESULT($have_pthread_t)
1819
if test "$have_pthread_t" = yes ; then
1820
AC_CHECK_SIZEOF(pthread_t, [], [
1821
#ifdef HAVE_PTHREAD_H
1822
#include <pthread.h>
1828
AC_SUBST(OTHER_LIBTOOL_OPT)
1829
case $ac_sys_system/$ac_sys_release in
1830
Darwin/@<:@01567@:>@\..*)
1831
OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1834
OTHER_LIBTOOL_OPT=""
1839
AC_SUBST(LIBTOOL_CRUFT)
1840
case $ac_sys_system/$ac_sys_release in
1841
Darwin/@<:@01567@:>@\..*)
1842
LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1843
if test "${enable_universalsdk}"; then
1846
LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `/usr/bin/arch`"
1848
LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1849
LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1851
gcc_version=`gcc -dumpversion`
1852
if test ${gcc_version} '<' 4.0
1854
LIBTOOL_CRUFT="-lcc_dynamic"
1858
AC_RUN_IFELSE([AC_LANG_SOURCE([[
1860
int main(int argc, char*argv[])
1862
if (sizeof(long) == 4) {
1868
]])],[ac_osx_32bit=yes],[ac_osx_32bit=no],[ac_osx_32bit=yes])
1870
if test "${ac_osx_32bit}" = "yes"; then
1871
case `/usr/bin/arch` in
1873
MACOSX_DEFAULT_ARCH="i386"
1876
MACOSX_DEFAULT_ARCH="ppc"
1879
AC_MSG_ERROR([Unexpected output of 'arch' on OSX])
1883
case `/usr/bin/arch` in
1885
MACOSX_DEFAULT_ARCH="x86_64"
1888
MACOSX_DEFAULT_ARCH="ppc64"
1891
AC_MSG_ERROR([Unexpected output of 'arch' on OSX])
1897
LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only ${MACOSX_DEFAULT_ARCH}"
1898
LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1899
LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1901
AC_MSG_CHECKING(for --enable-framework)
1902
if test "$enable_framework"
1904
BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1905
# -F. is needed to allow linking to the framework while
1906
# in the build location.
1907
AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1908
[Define if you want to produce an OpenStep/Rhapsody framework
1909
(shared library plus accessory files).])
1911
if test $enable_shared = "yes"
1913
AC_MSG_ERROR([Specifying both --enable-shared and --enable-framework is not supported, use only --enable-framework instead])
1919
AC_MSG_CHECKING(for dyld)
1920
case $ac_sys_system/$ac_sys_release in
1922
AC_DEFINE(WITH_DYLD, 1,
1923
[Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1924
dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1925
linker (rld). Dyld is necessary to support frameworks.])
1926
AC_MSG_RESULT(always on for Darwin)
1933
# Set info about shared libraries.
1934
AC_SUBST(SHLIB_SUFFIX)
1936
AC_SUBST(LDCXXSHARED)
1939
AC_SUBST(LINKFORSHARED)
1941
# SHLIB_SUFFIX is the extension of shared libraries `(including the dot!)
1942
# -- usually .so, .sl on HP-UX, .dll on Cygwin
1943
AC_MSG_CHECKING(the extension of shared libraries)
1944
if test -z "$SHLIB_SUFFIX"; then
1945
case $ac_sys_system in
1948
ia64) SHLIB_SUFFIX=.so;;
1949
*) SHLIB_SUFFIX=.sl;;
1952
CYGWIN*) SHLIB_SUFFIX=.dll;;
1953
*) SHLIB_SUFFIX=.so;;
1956
AC_MSG_RESULT($SHLIB_SUFFIX)
1958
# LDSHARED is the ld *command* used to create shared library
1959
# -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1960
# (Shared libraries in this instance are shared modules to be loaded into
1961
# Python, as opposed to building Python itself as a shared library.)
1962
AC_MSG_CHECKING(LDSHARED)
1963
if test -z "$LDSHARED"
1965
case $ac_sys_system/$ac_sys_release in
1967
BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:\$(srcdir)/Modules/python.exp"
1968
LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1970
IRIX/5*) LDSHARED="ld -shared";;
1971
IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1973
if test "$GCC" = "yes" ; then
1974
LDSHARED='$(CC) -shared'
1975
LDCXXSHARED='$(CXX) -shared'
1978
LDCXXSHARED='$(CXX) -G'
1981
if test "$GCC" = "yes" ; then
1982
LDSHARED='$(CC) -shared'
1983
LDCXXSHARED='$(CXX) -shared'
1988
LDSHARED='$(CC) -bundle'
1989
LDCXXSHARED='$(CXX) -bundle'
1990
if test "$enable_framework" ; then
1991
# Link against the framework. All externals should be defined.
1992
BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1993
LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1994
LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1996
# No framework. Ignore undefined symbols, assuming they come from Python
1997
LDSHARED="$LDSHARED -undefined suppress"
1998
LDCXXSHARED="$LDCXXSHARED -undefined suppress"
2000
Darwin/1.4*|Darwin/5.*|Darwin/6.*)
2001
LDSHARED='$(CC) -bundle'
2002
LDCXXSHARED='$(CXX) -bundle'
2003
if test "$enable_framework" ; then
2004
# Link against the framework. All externals should be defined.
2005
BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2006
LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2007
LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2009
# No framework, use the Python app as bundle-loader
2010
BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
2011
LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
2012
LDCXXSHARED="$LDCXXSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
2015
# Use -undefined dynamic_lookup whenever possible (10.3 and later).
2016
# This allows an extension to be used in any Python
2018
if test ${MACOSX_DEPLOYMENT_TARGET} '>' 10.2
2020
LDSHARED='$(CC) -bundle -undefined dynamic_lookup'
2021
LDCXXSHARED='$(CXX) -bundle -undefined dynamic_lookup'
2022
BLDSHARED="$LDSHARED"
2024
LDSHARED='$(CC) -bundle'
2025
LDCXXSHARED='$(CXX) -bundle'
2026
if test "$enable_framework" ; then
2027
# Link against the framework. All externals should be defined.
2028
BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2029
LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2030
LDCXXSHARED="$LDCXXSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2032
# No framework, use the Python app as bundle-loader
2033
BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
2034
LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
2035
LDCXXSHARED="$LDCXXSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
2040
LDSHARED='$(CC) -shared'
2041
LDCXXSHARED='$(CXX) -shared';;
2043
LDSHARED="gcc -shared"
2044
LDCXXSHARED="g++ -shared";;
2046
if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
2048
LDSHARED='$(CC) -shared'
2049
LDCXXSHARED='$(CXX) -shared'
2051
LDSHARED="ld -Bshareable"
2054
if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
2056
LDSHARED='$(CC) -shared $(CCSHARED)'
2057
LDCXXSHARED='$(CXX) -shared $(CCSHARED)'
2060
[[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
2061
LDSHARED="ld -Bshareable ${LDFLAGS}"
2064
LDSHARED='$(CC) -shared $(CCSHARED)'
2065
LDCXXSHARED='$(CXX) -shared $(CCSHARED)'
2070
LDSHARED='$(CC) -shared'
2071
LDCXXSHARED='$(CXX) -shared';;
2072
OpenUNIX*|UnixWare*)
2073
if test "$GCC" = "yes" ; then
2074
LDSHARED='$(CC) -shared'
2075
LDCXXSHARED='$(CXX) -shared'
2078
LDCXXSHARED='$(CXX) -G'
2081
LDSHARED='$(CC) -Wl,-G,-Bexport'
2082
LDCXXSHARED='$(CXX) -Wl,-G,-Bexport';;
2084
LDSHARED="gcc -shared -Wl,--enable-auto-image-base"
2085
LDCXXSHARED="g++ -shared -Wl,--enable-auto-image-base";;
2089
AC_MSG_RESULT($LDSHARED)
2090
LDCXXSHARED=${LDCXXSHARED-$LDSHARED}
2091
BLDSHARED=${BLDSHARED-$LDSHARED}
2092
# CCSHARED are the C *flags* used to create objects to go into a shared
2093
# library (module) -- this is only needed for a few systems
2094
AC_MSG_CHECKING(CCSHARED)
2095
if test -z "$CCSHARED"
2097
case $ac_sys_system/$ac_sys_release in
2098
SunOS*) if test "$GCC" = yes;
2099
then CCSHARED="-fPIC";
2100
elif test `uname -p` = sparc;
2101
then CCSHARED="-xcode=pic32";
2102
else CCSHARED="-Kpic";
2104
hp*|HP*) if test "$GCC" = yes;
2105
then CCSHARED="-fPIC";
2108
Linux*|GNU*) CCSHARED="-fPIC";;
2109
BSD/OS*/4*) CCSHARED="-fpic";;
2110
FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
2111
OpenUNIX*|UnixWare*)
2112
if test "$GCC" = "yes"
2113
then CCSHARED="-fPIC"
2114
else CCSHARED="-KPIC"
2117
if test "$GCC" = "yes"
2118
then CCSHARED="-fPIC"
2119
else CCSHARED="-Kpic -belf"
2121
IRIX*/6*) case $CC in
2122
*gcc*) CCSHARED="-shared";;
2127
AC_MSG_RESULT($CCSHARED)
2128
# LINKFORSHARED are the flags passed to the $(CC) command that links
2129
# the python executable -- this is only needed for a few systems
2130
AC_MSG_CHECKING(LINKFORSHARED)
2131
if test -z "$LINKFORSHARED"
2133
case $ac_sys_system/$ac_sys_release in
2134
AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
2136
LINKFORSHARED="-Wl,-E -Wl,+s";;
2137
# LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
2138
BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
2139
Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
2140
# -u libsys_s pulls in all symbols in libsys
2142
LINKFORSHARED="$extra_undefs -framework CoreFoundation"
2144
# Issue #18075: the default maximum stack size (8MBytes) is too
2145
# small for the default recursion limit. Increase the stack size
2146
# to ensure that tests don't crash
2147
LINKFORSHARED="-Wl,-stack_size,1000000 $LINKFORSHARED"
2149
if test "$enable_framework"
2151
LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
2153
LINKFORSHARED="$LINKFORSHARED";;
2154
OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
2155
SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
2156
ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
2157
FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
2158
if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
2160
LINKFORSHARED="-Wl,--export-dynamic"
2162
SunOS/5*) case $CC in
2164
if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
2166
LINKFORSHARED="-Xlinker --export-dynamic"
2170
if test $enable_shared = "no"
2172
LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
2175
# -Wl,-E causes the symbols to be added to the dynamic
2176
# symbol table so that they can be found when a module
2177
# is loaded. -N 2048K causes the stack size to be set
2178
# to 2048 kilobytes so that the stack doesn't overflow
2179
# when running test_compile.py.
2180
LINKFORSHARED='-Wl,-E -N 2048K';;
2183
AC_MSG_RESULT($LINKFORSHARED)
2186
AC_SUBST(CFLAGSFORSHARED)
2187
AC_MSG_CHECKING(CFLAGSFORSHARED)
2188
if test ! "$LIBRARY" = "$LDLIBRARY"
2190
case $ac_sys_system in
2192
# Cygwin needs CCSHARED when building extension DLLs
2193
# but not when building the interpreter DLL.
2194
CFLAGSFORSHARED='';;
2196
CFLAGSFORSHARED='$(CCSHARED)'
2199
AC_MSG_RESULT($CFLAGSFORSHARED)
2201
# SHLIBS are libraries (except -lc and -lm) to link to the python shared
2202
# library (with --enable-shared).
2203
# For platforms on which shared libraries are not allowed to have unresolved
2204
# symbols, this must be set to $(LIBS) (expanded by make). We do this even
2205
# if it is not required, since it creates a dependency of the shared library
2206
# to LIBS. This, in turn, means that applications linking the shared libpython
2207
# don't need to link LIBS explicitly. The default should be only changed
2208
# on systems where this approach causes problems.
2210
AC_MSG_CHECKING(SHLIBS)
2211
case "$ac_sys_system" in
2215
AC_MSG_RESULT($SHLIBS)
2218
# checks for libraries
2219
AC_CHECK_LIB(sendfile, sendfile)
2220
AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
2221
AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
2223
# only check for sem_init if thread support is requested
2224
if test "$with_threads" = "yes" -o -z "$with_threads"; then
2225
AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
2226
# posix4 on Solaris 2.6
2227
# pthread (first!) on Linux
2230
# check if we need libintl for locale functions
2231
AC_CHECK_LIB(intl, textdomain,
2232
[AC_DEFINE(WITH_LIBINTL, 1,
2233
[Define to 1 if libintl is needed for locale functions.])
2234
LIBS="-lintl $LIBS"])
2236
# checks for system dependent C++ extensions support
2237
case "$ac_sys_system" in
2238
AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
2240
AC_LANG_PROGRAM([[#include <load.h>]],
2241
[[loadAndInit("", 0, "")]])
2243
AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
2244
[Define for AIX if your compiler is a genuine IBM xlC/xlC_r
2245
and you want support for AIX C++ shared extension modules.])
2253
# check for systems that require aligned memory access
2254
AC_MSG_CHECKING(aligned memory access is required)
2260
for (i=0; i < 16; i++)
2269
[aligned_required=no],
2270
[aligned_required=yes],
2271
[aligned_required=yes])
2273
if test "$aligned_required" = yes ; then
2274
AC_DEFINE([HAVE_ALIGNED_REQUIRED], [1],
2275
[Define if aligned memory access is required])
2277
AC_MSG_RESULT($aligned_required)
2280
# str, bytes and memoryview hash algorithm
2281
AH_TEMPLATE(Py_HASH_ALGORITHM,
2282
[Define hash algorithm for str, bytes and memoryview.
2283
SipHash24: 1, FNV: 2, externally defined: 0])
2285
AC_MSG_CHECKING(for --with-hash-algorithm)
2286
dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2287
AC_ARG_WITH(hash_algorithm,
2288
AS_HELP_STRING([--with-hash-algorithm=@<:@fnv|siphash24@:>@],
2289
[select hash algorithm]),
2291
AC_MSG_RESULT($withval)
2294
AC_DEFINE(Py_HASH_ALGORITHM, 1)
2297
AC_DEFINE(Py_HASH_ALGORITHM, 2)
2300
AC_MSG_ERROR([unknown hash algorithm '$withval'])
2304
[AC_MSG_RESULT(default)])
2306
# Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
2307
AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
2308
AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
2310
AC_MSG_CHECKING(for --with-libs)
2312
AS_HELP_STRING([--with-libs='lib1 ...'], [link against additional libs]),
2314
AC_MSG_RESULT($withval)
2315
LIBS="$withval $LIBS"
2317
[AC_MSG_RESULT(no)])
2319
AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
2321
# Check for use of the system expat library
2322
AC_MSG_CHECKING(for --with-system-expat)
2323
AC_ARG_WITH(system_expat,
2324
AS_HELP_STRING([--with-system-expat], [build pyexpat module using an installed expat library]),
2326
[with_system_expat="no"])
2328
AC_MSG_RESULT($with_system_expat)
2330
# Check for use of the system libffi library
2331
AC_MSG_CHECKING(for --with-system-ffi)
2332
AC_ARG_WITH(system_ffi,
2333
AS_HELP_STRING([--with-system-ffi], [build _ctypes module using an installed ffi library]),
2335
[with_system_ffi="no"])
2337
if test "$with_system_ffi" = "yes" && test -n "$PKG_CONFIG"; then
2338
LIBFFI_INCLUDEDIR="`"$PKG_CONFIG" libffi --cflags-only-I 2>/dev/null | sed -e 's/^-I//;s/ *$//'`"
2340
LIBFFI_INCLUDEDIR=""
2342
AC_SUBST(LIBFFI_INCLUDEDIR)
2344
AC_MSG_RESULT($with_system_ffi)
2346
# Check for use of the system libmpdec library
2347
AC_MSG_CHECKING(for --with-system-libmpdec)
2348
AC_ARG_WITH(system_libmpdec,
2349
AS_HELP_STRING([--with-system-libmpdec], [build _decimal module using an installed libmpdec library]),
2351
[with_system_libmpdec="no"])
2353
AC_MSG_RESULT($with_system_libmpdec)
2355
# Check for support for loadable sqlite extensions
2356
AC_MSG_CHECKING(for --enable-loadable-sqlite-extensions)
2357
AC_ARG_ENABLE(loadable-sqlite-extensions,
2358
AS_HELP_STRING([--enable-loadable-sqlite-extensions], [support loadable extensions in _sqlite module]),
2360
[enable_loadable_sqlite_extensions="no"])
2362
AC_MSG_RESULT($enable_loadable_sqlite_extensions)
2364
# Check for --with-tcltk-includes=path and --with-tcltk-libs=path
2365
AC_SUBST(TCLTK_INCLUDES)
2366
AC_SUBST(TCLTK_LIBS)
2367
AC_MSG_CHECKING(for --with-tcltk-includes)
2368
AC_ARG_WITH(tcltk-includes,
2369
AS_HELP_STRING([--with-tcltk-includes='-I...'], [override search for Tcl and Tk include files]),
2371
[with_tcltk_includes="default"])
2372
AC_MSG_RESULT($with_tcltk_includes)
2373
AC_MSG_CHECKING(for --with-tcltk-libs)
2374
AC_ARG_WITH(tcltk-libs,
2375
AS_HELP_STRING([--with-tcltk-libs='-L...'], [override search for Tcl and Tk libs]),
2377
[with_tcltk_libs="default"])
2378
AC_MSG_RESULT($with_tcltk_libs)
2379
if test "x$with_tcltk_includes" = xdefault || test "x$with_tcltk_libs" = xdefault
2381
if test "x$with_tcltk_includes" != "x$with_tcltk_libs"
2383
AC_MSG_ERROR([use both --with-tcltk-includes='...' and --with-tcltk-libs='...' or neither])
2388
TCLTK_INCLUDES="$with_tcltk_includes"
2389
TCLTK_LIBS="$with_tcltk_libs"
2392
# Check for --with-dbmliborder
2393
AC_MSG_CHECKING(for --with-dbmliborder)
2394
AC_ARG_WITH(dbmliborder,
2395
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'.]),
2397
if test x$with_dbmliborder = xyes
2399
AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
2401
for db in `echo $with_dbmliborder | sed 's/:/ /g'`; do
2402
if test x$db != xndbm && test x$db != xgdbm && test x$db != xbdb
2404
AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
2408
AC_MSG_RESULT($with_dbmliborder)
2410
# Determine if signalmodule should be used.
2411
AC_SUBST(USE_SIGNAL_MODULE)
2412
AC_SUBST(SIGNAL_OBJS)
2413
AC_MSG_CHECKING(for --with-signal-module)
2414
AC_ARG_WITH(signal-module,
2415
AS_HELP_STRING([--with-signal-module], [disable/enable signal module]))
2417
if test -z "$with_signal_module"
2418
then with_signal_module="yes"
2420
AC_MSG_RESULT($with_signal_module)
2422
if test "${with_signal_module}" = "yes"; then
2423
USE_SIGNAL_MODULE=""
2426
USE_SIGNAL_MODULE="#"
2427
SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
2430
# This is used to generate Setup.config
2431
AC_SUBST(USE_THREAD_MODULE)
2432
USE_THREAD_MODULE=""
2436
# Templates for things AC_DEFINEd more than once.
2437
# For a single AC_DEFINE, no template is needed.
2438
AH_TEMPLATE(_REENTRANT,
2439
[Define to force use of thread-safe errno, h_errno, and other functions])
2440
AH_TEMPLATE(WITH_THREAD,
2441
[Define if you want to compile in rudimentary thread support])
2443
AC_MSG_CHECKING(for --with-threads)
2444
dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2445
AC_ARG_WITH(threads,
2446
AS_HELP_STRING([--with(out)-threads@<:@=DIRECTORY@:>@], [disable/enable thread support]))
2448
# --with-thread is deprecated, but check for it anyway
2449
dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2451
AS_HELP_STRING([--with(out)-thread@<:@=DIRECTORY@:>@], [deprecated; use --with(out)-threads]),
2452
[with_threads=$with_thread])
2454
if test -z "$with_threads"
2455
then with_threads="yes"
2457
AC_MSG_RESULT($with_threads)
2460
if test "$with_threads" = "no"
2462
USE_THREAD_MODULE="#"
2463
elif test "$ac_cv_pthread_is_default" = yes
2465
AC_DEFINE(WITH_THREAD)
2466
# Defining _REENTRANT on system with POSIX threads should not hurt.
2467
AC_DEFINE(_REENTRANT)
2469
THREADOBJ="Python/thread.o"
2470
elif test "$ac_cv_kpthread" = "yes"
2473
if test "$ac_cv_cxx_thread" = "yes"; then
2474
CXX="$CXX -Kpthread"
2476
AC_DEFINE(WITH_THREAD)
2478
THREADOBJ="Python/thread.o"
2479
elif test "$ac_cv_kthread" = "yes"
2482
if test "$ac_cv_cxx_thread" = "yes"; then
2485
AC_DEFINE(WITH_THREAD)
2487
THREADOBJ="Python/thread.o"
2488
elif test "$ac_cv_pthread" = "yes"
2491
if test "$ac_cv_cxx_thread" = "yes"; then
2494
AC_DEFINE(WITH_THREAD)
2496
THREADOBJ="Python/thread.o"
2498
if test ! -z "$with_threads" -a -d "$with_threads"
2499
then LDFLAGS="$LDFLAGS -L$with_threads"
2501
if test ! -z "$withval" -a -d "$withval"
2502
then LDFLAGS="$LDFLAGS -L$withval"
2505
# According to the POSIX spec, a pthreads implementation must
2506
# define _POSIX_THREADS in unistd.h. Some apparently don't
2507
# (e.g. gnu pth with pthread emulation)
2508
AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
2512
#ifdef _POSIX_THREADS
2515
], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
2516
AC_MSG_RESULT($unistd_defines_pthreads)
2518
AC_DEFINE(_REENTRANT)
2519
# Just looking for pthread_create in libpthread is not enough:
2520
# on HP/UX, pthread.h renames pthread_create to a different symbol name.
2521
# So we really have to include pthread.h, and then link.
2523
LIBS="$LIBS -lpthread"
2524
AC_MSG_CHECKING([for pthread_create in -lpthread])
2525
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2527
#include <pthread.h>
2529
void * start_routine (void *arg) { exit (0); }]], [[
2530
pthread_create (NULL, NULL, start_routine, NULL)]])],[
2532
AC_DEFINE(WITH_THREAD)
2534
THREADOBJ="Python/thread.o"],[
2536
AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
2538
THREADOBJ="Python/thread.o"],[
2539
AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
2541
LIBS="$LIBS -lpthreads"
2542
THREADOBJ="Python/thread.o"], [
2543
AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
2546
THREADOBJ="Python/thread.o"], [
2547
AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
2549
LIBS="$LIBS -lpthread"
2550
THREADOBJ="Python/thread.o"], [
2551
AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
2554
THREADOBJ="Python/thread.o"],[
2555
USE_THREAD_MODULE="#"])
2558
AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
2560
THREADOBJ="Python/thread.o"
2561
USE_THREAD_MODULE=""])
2563
if test "$posix_threads" != "yes"; then
2564
AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
2565
LIBS="$LIBS -lthread"
2566
THREADOBJ="Python/thread.o"
2567
USE_THREAD_MODULE=""])
2571
if test "$posix_threads" = "yes"; then
2572
if test "$unistd_defines_pthreads" = "no"; then
2573
AC_DEFINE(_POSIX_THREADS, 1,
2574
[Define if you have POSIX threads,
2575
and your system does not define that.])
2578
# Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
2579
case $ac_sys_system/$ac_sys_release in
2580
SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
2581
[Defined for Solaris 2.6 bug in pthread header.])
2583
SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2584
[Define if the Posix semaphores do not work on your system])
2586
AIX/*) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2587
[Define if the Posix semaphores do not work on your system])
2591
AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
2592
AC_CACHE_VAL(ac_cv_pthread_system_supported,
2593
[AC_RUN_IFELSE([AC_LANG_SOURCE([[
2595
#include <pthread.h>
2596
void *foo(void *parm) {
2600
pthread_attr_t attr;
2602
if (pthread_attr_init(&attr)) exit(-1);
2603
if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
2604
if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
2607
[ac_cv_pthread_system_supported=yes],
2608
[ac_cv_pthread_system_supported=no],
2609
[ac_cv_pthread_system_supported=no])
2611
AC_MSG_RESULT($ac_cv_pthread_system_supported)
2612
if test "$ac_cv_pthread_system_supported" = "yes"; then
2613
AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2615
AC_CHECK_FUNCS(pthread_sigmask,
2616
[case $ac_sys_system in
2618
AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2619
[Define if pthread_sigmask() does not work on your system.])
2622
AC_CHECK_FUNCS(pthread_atfork)
2626
# Check for enable-ipv6
2627
AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2628
AC_MSG_CHECKING([if --enable-ipv6 is specified])
2630
[ --enable-ipv6 Enable ipv6 (with ipv4) support
2631
--disable-ipv6 Disable ipv6 support],
2632
[ case "$enableval" in
2637
*) AC_MSG_RESULT(yes)
2638
AC_DEFINE(ENABLE_IPV6)
2644
dnl the check does not work on cross compilation case...
2645
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ /* AF_INET6 available check */
2646
#include <sys/types.h>
2647
#include <sys/socket.h>]],
2648
[[int domain = AF_INET6;]])],[
2656
if test "$ipv6" = "yes"; then
2657
AC_MSG_CHECKING(if RFC2553 API is available)
2659
AC_LANG_PROGRAM([[#include <sys/types.h>
2660
#include <netinet/in.h>]],
2661
[[struct sockaddr_in6 x;
2667
AC_MSG_RESULT(no, IPv6 disabled)
2672
if test "$ipv6" = "yes"; then
2673
AC_DEFINE(ENABLE_IPV6)
2681
if test "$ipv6" = "yes"; then
2682
AC_MSG_CHECKING([ipv6 stack type])
2683
for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2687
dnl http://www.kame.net/
2689
#include <netinet/in.h>
2690
#ifdef IPV6_INRIA_VERSION
2696
dnl http://www.kame.net/
2698
#include <netinet/in.h>
2704
ipv6libdir=/usr/local/v6/lib
2708
dnl http://www.v6.linux.or.jp/
2710
#include <features.h>
2711
#if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2718
dnl http://www.v6.linux.or.jp/
2719
if test -d /usr/inet6; then
2722
ipv6libdir=/usr/inet6/lib
2723
BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2727
if test -f /etc/netconfig; then
2728
if $GREP -q tcp6 /etc/netconfig; then
2736
#include <sys/param.h>
2737
#ifdef _TOSHIBA_INET6
2742
ipv6libdir=/usr/local/v6/lib])
2746
#include </usr/local/v6/include/sys/v6config.h>
2752
ipv6libdir=/usr/local/v6/lib;
2753
BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2757
#include <sys/param.h>
2758
#ifdef _ZETA_MINAMI_INET6
2763
ipv6libdir=/usr/local/v6/lib])
2766
if test "$ipv6type" != "unknown"; then
2770
AC_MSG_RESULT($ipv6type)
2773
if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2774
if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2775
LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2776
echo "using lib$ipv6lib"
2778
if test $ipv6trylibc = "yes"; then
2781
echo 'Fatal: no $ipv6lib library found. cannot continue.'
2782
echo "You need to fetch lib$ipv6lib.a from appropriate"
2783
echo 'ipv6 kit and compile beforehand.'
2789
AC_MSG_CHECKING(for OSX 10.5 SDK or later)
2791
AC_LANG_PROGRAM([[#include <Carbon/Carbon.h>]], [[FSIORefNum fRef = 0]])
2793
AC_DEFINE(HAVE_OSX105_SDK, 1, [Define if compiling using MacOS X 10.5 SDK or later.])
2799
# Check for --with-doc-strings
2800
AC_MSG_CHECKING(for --with-doc-strings)
2801
AC_ARG_WITH(doc-strings,
2802
AS_HELP_STRING([--with(out)-doc-strings], [disable/enable documentation strings]))
2804
if test -z "$with_doc_strings"
2805
then with_doc_strings="yes"
2807
if test "$with_doc_strings" != "no"
2809
AC_DEFINE(WITH_DOC_STRINGS, 1,
2810
[Define if you want documentation strings in extension modules])
2812
AC_MSG_RESULT($with_doc_strings)
2814
# Check if eval loop should use timestamp counter profiling
2815
AC_MSG_CHECKING(for --with-tsc)
2817
AS_HELP_STRING([--with(out)-tsc],[enable/disable timestamp counter profile]),[
2818
if test "$withval" != no
2820
AC_DEFINE(WITH_TSC, 1,
2821
[Define to profile with the Pentium timestamp counter])
2823
else AC_MSG_RESULT(no)
2825
[AC_MSG_RESULT(no)])
2827
# Check for Python-specific malloc support
2828
AC_MSG_CHECKING(for --with-pymalloc)
2829
AC_ARG_WITH(pymalloc,
2830
AS_HELP_STRING([--with(out)-pymalloc], [disable/enable specialized mallocs]))
2832
if test -z "$with_pymalloc"
2836
if test "$with_pymalloc" != "no"
2838
AC_DEFINE(WITH_PYMALLOC, 1,
2839
[Define if you want to compile in Python-specific mallocs])
2840
ABIFLAGS="${ABIFLAGS}m"
2842
AC_MSG_RESULT($with_pymalloc)
2844
# Check for Valgrind support
2845
AC_MSG_CHECKING([for --with-valgrind])
2846
AC_ARG_WITH([valgrind],
2847
AS_HELP_STRING([--with-valgrind], [Enable Valgrind support]),,
2849
AC_MSG_RESULT([$with_valgrind])
2850
if test "$with_valgrind" != no; then
2851
AC_CHECK_HEADER([valgrind/valgrind.h],
2852
[AC_DEFINE([WITH_VALGRIND], 1, [Define if you want pymalloc to be disabled when running under valgrind])],
2853
[AC_MSG_ERROR([Valgrind support requested but headers not available])]
2855
OPT="-DDYNAMIC_ANNOTATIONS_ENABLED=1 $OPT"
2858
# -I${DLINCLDIR} is added to the compile rule for importdl.o
2862
# the dlopen() function means we might want to use dynload_shlib.o. some
2863
# platforms, such as AIX, have dlopen(), but don't want to use it.
2864
AC_CHECK_FUNCS(dlopen)
2866
# DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2867
# loading of modules.
2868
AC_SUBST(DYNLOADFILE)
2869
AC_MSG_CHECKING(DYNLOADFILE)
2870
if test -z "$DYNLOADFILE"
2872
case $ac_sys_system/$ac_sys_release in
2873
AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2874
if test "$ac_cv_func_dlopen" = yes
2875
then DYNLOADFILE="dynload_shlib.o"
2876
else DYNLOADFILE="dynload_aix.o"
2879
hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2880
# Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2881
Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2883
# use dynload_shlib.c and dlopen() if we have it; otherwise stub
2884
# out any dynamic loading
2885
if test "$ac_cv_func_dlopen" = yes
2886
then DYNLOADFILE="dynload_shlib.o"
2887
else DYNLOADFILE="dynload_stub.o"
2892
AC_MSG_RESULT($DYNLOADFILE)
2893
if test "$DYNLOADFILE" != "dynload_stub.o"
2895
AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2896
[Defined when any dynamic module loading is enabled.])
2899
# MACHDEP_OBJS can be set to platform-specific object files needed by Python
2901
AC_SUBST(MACHDEP_OBJS)
2902
AC_MSG_CHECKING(MACHDEP_OBJS)
2903
if test -z "$MACHDEP_OBJS"
2905
MACHDEP_OBJS=$extra_machdep_objs
2907
MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2909
if test -z "$MACHDEP_OBJS"; then
2910
AC_MSG_RESULT([none])
2912
AC_MSG_RESULT([$MACHDEP_OBJS])
2915
# checks for library functions
2916
AC_CHECK_FUNCS(alarm accept4 setitimer getitimer bind_textdomain_codeset chown \
2917
clock confstr ctermid dup3 execv faccessat fchmod fchmodat fchown fchownat \
2918
fexecve fdopendir fork fpathconf fstatat ftime ftruncate futimesat \
2919
futimens futimes gai_strerror \
2920
getgrouplist getgroups getlogin getloadavg getpeername getpgid getpid \
2921
getpriority getresuid getresgid getpwent getspnam getspent getsid getwd \
2923
initgroups kill killpg lchmod lchown lockf linkat lstat lutimes mmap \
2924
memrchr mbrtowc mkdirat mkfifo \
2925
mkfifoat mknod mknodat mktime mremap nice openat pathconf pause pipe2 plock poll \
2926
posix_fallocate posix_fadvise pread \
2927
pthread_init pthread_kill putenv pwrite readlink readlinkat readv realpath renameat \
2928
select sem_open sem_timedwait sem_getvalue sem_unlink sendfile setegid seteuid \
2929
setgid sethostname \
2930
setlocale setregid setreuid setresuid setresgid setsid setpgid setpgrp setpriority setuid setvbuf \
2931
sched_get_priority_max sched_setaffinity sched_setscheduler sched_setparam \
2932
sched_rr_get_interval \
2933
sigaction sigaltstack siginterrupt sigpending sigrelse \
2934
sigtimedwait sigwait sigwaitinfo snprintf strftime strlcpy symlinkat sync \
2935
sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2936
truncate uname unlinkat unsetenv utimensat utimes waitid waitpid wait3 wait4 \
2937
wcscoll wcsftime wcsxfrm wmemcmp writev _getpty)
2939
AC_CHECK_DECL(dirfd,
2940
AC_DEFINE(HAVE_DIRFD, 1,
2941
Define if you have the 'dirfd' function or macro.), ,
2942
[#include <sys/types.h>
2943
#include <dirent.h>])
2945
# For some functions, having a definition is not sufficient, since
2946
# we want to take their address.
2947
AC_MSG_CHECKING(for chroot)
2948
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=chroot]])],
2949
[AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2950
AC_MSG_RESULT(yes)],
2953
AC_MSG_CHECKING(for link)
2954
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=link]])],
2955
[AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2956
AC_MSG_RESULT(yes)],
2959
AC_MSG_CHECKING(for symlink)
2960
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=symlink]])],
2961
[AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2962
AC_MSG_RESULT(yes)],
2965
AC_MSG_CHECKING(for fchdir)
2966
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=fchdir]])],
2967
[AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2968
AC_MSG_RESULT(yes)],
2971
AC_MSG_CHECKING(for fsync)
2972
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=fsync]])],
2973
[AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2974
AC_MSG_RESULT(yes)],
2977
AC_MSG_CHECKING(for fdatasync)
2978
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[void *x=fdatasync]])],
2979
[AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2980
AC_MSG_RESULT(yes)],
2983
AC_MSG_CHECKING(for epoll)
2984
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/epoll.h>]], [[void *x=epoll_create]])],
2985
[AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
2986
AC_MSG_RESULT(yes)],
2989
AC_MSG_CHECKING(for epoll_create1)
2990
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/epoll.h>]], [[void *x=epoll_create1]])],
2991
[AC_DEFINE(HAVE_EPOLL_CREATE1, 1, Define if you have the 'epoll_create1' function.)
2992
AC_MSG_RESULT(yes)],
2995
AC_MSG_CHECKING(for kqueue)
2996
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
2997
#include <sys/types.h>
2998
#include <sys/event.h>
2999
]], [[int x=kqueue()]])],
3000
[AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
3001
AC_MSG_RESULT(yes)],
3004
AC_MSG_CHECKING(for prlimit)
3005
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3006
#include <sys/time.h>
3007
#include <sys/resource.h>
3008
]], [[void *x=prlimit]])],
3009
[AC_DEFINE(HAVE_PRLIMIT, 1, Define if you have the 'prlimit' functions.)
3010
AC_MSG_RESULT(yes)],
3014
# On some systems (eg. FreeBSD 5), we would find a definition of the
3015
# functions ctermid_r, setgroups in the library, but no prototype
3016
# (e.g. because we use _XOPEN_SOURCE). See whether we can take their
3017
# address to avoid compiler warnings and potential miscompilations
3018
# because of the missing prototypes.
3020
AC_MSG_CHECKING(for ctermid_r)
3021
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3023
]], [[void* p = ctermid_r]])],
3024
[AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
3025
AC_MSG_RESULT(yes)],
3029
AC_CACHE_CHECK([for flock declaration], [ac_cv_flock_decl],
3032
[#include <sys/file.h>],
3035
[ac_cv_flock_decl=yes],
3036
[ac_cv_flock_decl=no]
3039
if test "x${ac_cv_flock_decl}" = xyes; then
3040
AC_CHECK_FUNCS(flock,,
3041
AC_CHECK_LIB(bsd,flock,
3042
[AC_DEFINE(HAVE_FLOCK)
3043
AC_DEFINE(FLOCK_NEEDS_LIBBSD, 1, Define if flock needs to be linked with bsd library.)
3048
AC_MSG_CHECKING(for getpagesize)
3049
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3051
]], [[void* p = getpagesize]])],
3052
[AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
3053
AC_MSG_RESULT(yes)],
3057
AC_MSG_CHECKING(for broken unsetenv)
3058
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3060
]], [[int res = unsetenv("DUMMY")]])],
3061
[AC_MSG_RESULT(no)],
3062
[AC_DEFINE(HAVE_BROKEN_UNSETENV, 1, Define if `unsetenv` does not return an int.)
3067
AC_CHECK_PROGS(TRUE, true, /bin/true)
3069
dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
3070
dnl On others, they are in the C library, so we to take no action
3071
AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
3072
AC_CHECK_LIB(resolv, inet_aton)
3075
# On Tru64, chflags seems to be present, but calling it will
3077
AC_CACHE_CHECK([for chflags], [ac_cv_have_chflags], [dnl
3078
AC_RUN_IFELSE([AC_LANG_SOURCE([[
3079
#include <sys/stat.h>
3081
int main(int argc, char*argv[])
3083
if(chflags(argv[0], 0) != 0)
3088
[ac_cv_have_chflags=yes],
3089
[ac_cv_have_chflags=no],
3090
[ac_cv_have_chflags=cross])
3092
if test "$ac_cv_have_chflags" = cross ; then
3093
AC_CHECK_FUNC([chflags], [ac_cv_have_chflags="yes"], [ac_cv_have_chflags="no"])
3095
if test "$ac_cv_have_chflags" = yes ; then
3096
AC_DEFINE(HAVE_CHFLAGS, 1, [Define to 1 if you have the 'chflags' function.])
3099
AC_CACHE_CHECK([for lchflags], [ac_cv_have_lchflags], [dnl
3100
AC_RUN_IFELSE([AC_LANG_SOURCE([[
3101
#include <sys/stat.h>
3103
int main(int argc, char*argv[])
3105
if(lchflags(argv[0], 0) != 0)
3109
]])],[ac_cv_have_lchflags=yes],[ac_cv_have_lchflags=no],[ac_cv_have_lchflags=cross])
3111
if test "$ac_cv_have_lchflags" = cross ; then
3112
AC_CHECK_FUNC([lchflags], [ac_cv_have_lchflags="yes"], [ac_cv_have_lchflags="no"])
3114
if test "$ac_cv_have_lchflags" = yes ; then
3115
AC_DEFINE(HAVE_LCHFLAGS, 1, [Define to 1 if you have the 'lchflags' function.])
3118
dnl Check if system zlib has *Copy() functions
3120
dnl On MacOSX the linker will search for dylibs on the entire linker path
3121
dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
3122
dnl to revert to a more traditional unix behaviour and make it possible to
3123
dnl override the system libz with a local static library of libz. Temporarily
3124
dnl add that flag to our CFLAGS as well to ensure that we check the version
3125
dnl of libz that will be used by setup.py.
3126
dnl The -L/usr/local/lib is needed as wel to get the same compilation
3127
dnl environment as setup.py (and leaving it out can cause configure to use the
3128
dnl wrong version of the library)
3129
case $ac_sys_system/$ac_sys_release in
3131
_CUR_CFLAGS="${CFLAGS}"
3132
_CUR_LDFLAGS="${LDFLAGS}"
3133
CFLAGS="${CFLAGS} -Wl,-search_paths_first"
3134
LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
3138
AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, [Define if the zlib library has inflateCopy]))
3140
case $ac_sys_system/$ac_sys_release in
3142
CFLAGS="${_CUR_CFLAGS}"
3143
LDFLAGS="${_CUR_LDFLAGS}"
3147
AC_MSG_CHECKING(for hstrerror)
3148
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
3150
]], [[void* p = hstrerror; hstrerror(0)]])],
3151
[AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
3152
AC_MSG_RESULT(yes)],
3156
AC_MSG_CHECKING(for inet_aton)
3157
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
3158
#include <sys/types.h>
3159
#include <sys/socket.h>
3160
#include <netinet/in.h>
3161
#include <arpa/inet.h>
3162
]], [[void* p = inet_aton;inet_aton(0,0)]])],
3163
[AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
3164
AC_MSG_RESULT(yes)],
3168
AC_MSG_CHECKING(for inet_pton)
3169
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3170
#include <sys/types.h>
3171
#include <sys/socket.h>
3172
#include <netinet/in.h>
3173
#include <arpa/inet.h>
3174
]], [[void* p = inet_pton]])],
3175
[AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
3176
AC_MSG_RESULT(yes)],
3180
# On some systems, setgroups is in unistd.h, on others, in grp.h
3181
AC_MSG_CHECKING(for setgroups)
3182
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3187
]], [[void* p = setgroups]])],
3188
[AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
3189
AC_MSG_RESULT(yes)],
3193
# check for openpty and forkpty
3195
AC_CHECK_FUNCS(openpty,,
3196
AC_CHECK_LIB(util,openpty,
3197
[AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
3198
AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
3201
AC_CHECK_FUNCS(forkpty,,
3202
AC_CHECK_LIB(util,forkpty,
3203
[AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
3204
AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
3209
AC_CHECK_FUNCS(memmove)
3211
# check for long file support functions
3212
AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
3214
AC_REPLACE_FUNCS(dup2 strdup)
3215
AC_CHECK_FUNCS(getpgrp,
3216
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[getpgrp(0);]])],
3217
[AC_DEFINE(GETPGRP_HAVE_ARG, 1, [Define if getpgrp() must be called as getpgrp(0).])],
3220
AC_CHECK_FUNCS(setpgrp,
3221
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]], [[setpgrp(0,0);]])],
3222
[AC_DEFINE(SETPGRP_HAVE_ARG, 1, [Define if setpgrp() must be called as setpgrp(0, 0).])],
3225
AC_CHECK_FUNCS(gettimeofday,
3226
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/time.h>]],
3227
[[gettimeofday((struct timeval*)0,(struct timezone*)0);]])],
3229
[AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
3230
[Define if gettimeofday() does not have second (timezone) argument
3231
This is the case on Motorola V4 (R40V4.2)])
3235
AC_CHECK_FUNCS(clock_gettime, [], [
3236
AC_CHECK_LIB(rt, clock_gettime, [
3237
AC_DEFINE(HAVE_CLOCK_GETTIME, 1)
3238
AC_DEFINE(TIMEMODULE_LIB, [rt],
3239
[Library needed by timemodule.c: librt may be needed for clock_gettime()])
3243
AC_CHECK_FUNCS(clock_getres, [], [
3244
AC_CHECK_LIB(rt, clock_getres, [
3245
AC_DEFINE(HAVE_CLOCK_GETRES, 1)
3249
AC_MSG_CHECKING(for major, minor, and makedev)
3250
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
3251
#if defined(MAJOR_IN_MKDEV)
3252
#include <sys/mkdev.h>
3253
#elif defined(MAJOR_IN_SYSMACROS)
3254
#include <sys/sysmacros.h>
3256
#include <sys/types.h>
3259
makedev(major(0),minor(0));
3261
AC_DEFINE(HAVE_DEVICE_MACROS, 1,
3262
[Define to 1 if you have the device macros.])
3268
# On OSF/1 V5.1, getaddrinfo is available, but a define
3269
# for [no]getaddrinfo in netdb.h.
3270
AC_MSG_CHECKING(for getaddrinfo)
3271
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
3272
#include <sys/types.h>
3273
#include <sys/socket.h>
3276
]], [[getaddrinfo(NULL, NULL, NULL, NULL);]])],
3277
[have_getaddrinfo=yes],
3278
[have_getaddrinfo=no])
3279
AC_MSG_RESULT($have_getaddrinfo)
3280
if test $have_getaddrinfo = yes
3282
AC_MSG_CHECKING(getaddrinfo bug)
3283
AC_CACHE_VAL(ac_cv_buggy_getaddrinfo,
3284
AC_RUN_IFELSE([AC_LANG_SOURCE([[[
3286
#include <sys/types.h>
3289
#include <sys/socket.h>
3290
#include <netinet/in.h>
3294
int passive, gaierr, inet4 = 0, inet6 = 0;
3295
struct addrinfo hints, *ai, *aitop;
3296
char straddr[INET6_ADDRSTRLEN], strport[16];
3298
for (passive = 0; passive <= 1; passive++) {
3299
memset(&hints, 0, sizeof(hints));
3300
hints.ai_family = AF_UNSPEC;
3301
hints.ai_flags = passive ? AI_PASSIVE : 0;
3302
hints.ai_socktype = SOCK_STREAM;
3303
hints.ai_protocol = IPPROTO_TCP;
3304
if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
3305
(void)gai_strerror(gaierr);
3308
for (ai = aitop; ai; ai = ai->ai_next) {
3309
if (ai->ai_addr == NULL ||
3310
ai->ai_addrlen == 0 ||
3311
getnameinfo(ai->ai_addr, ai->ai_addrlen,
3312
straddr, sizeof(straddr), strport, sizeof(strport),
3313
NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
3316
switch (ai->ai_family) {
3318
if (strcmp(strport, "54321") != 0) {
3322
if (strcmp(straddr, "0.0.0.0") != 0) {
3326
if (strcmp(straddr, "127.0.0.1") != 0) {
3333
if (strcmp(strport, "54321") != 0) {
3337
if (strcmp(straddr, "::") != 0) {
3341
if (strcmp(straddr, "::1") != 0) {
3351
/* another family support? */
3357
if (!(inet4 == 0 || inet4 == 2))
3359
if (!(inet6 == 0 || inet6 == 2))
3363
freeaddrinfo(aitop);
3368
freeaddrinfo(aitop);
3372
[ac_cv_buggy_getaddrinfo=no],
3373
[ac_cv_buggy_getaddrinfo=yes],
3375
if test "${enable_ipv6+set}" = set; then
3376
ac_cv_buggy_getaddrinfo="no -- configured with --(en|dis)able-ipv6"
3378
ac_cv_buggy_getaddrinfo=yes
3382
AC_MSG_RESULT($ac_cv_buggy_getaddrinfo)
3384
if test $have_getaddrinfo = no || test "$ac_cv_buggy_getaddrinfo" = yes
3388
echo 'Fatal: You must get working getaddrinfo() function.'
3389
echo ' or you can specify "--disable-ipv6"'.
3393
AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
3396
AC_CHECK_FUNCS(getnameinfo)
3398
# checks for structures
3402
AC_CHECK_MEMBERS([struct stat.st_rdev])
3403
AC_CHECK_MEMBERS([struct stat.st_blksize])
3404
AC_CHECK_MEMBERS([struct stat.st_flags])
3405
AC_CHECK_MEMBERS([struct stat.st_gen])
3406
AC_CHECK_MEMBERS([struct stat.st_birthtime])
3409
AC_MSG_CHECKING(for time.h that defines altzone)
3410
AC_CACHE_VAL(ac_cv_header_time_altzone,[
3411
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[return altzone;]])],
3412
[ac_cv_header_time_altzone=yes],
3413
[ac_cv_header_time_altzone=no])
3415
AC_MSG_RESULT($ac_cv_header_time_altzone)
3416
if test $ac_cv_header_time_altzone = yes; then
3417
AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
3421
AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
3422
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3423
#include <sys/types.h>
3424
#include <sys/select.h>
3425
#include <sys/time.h>
3427
AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
3428
[Define if you can safely include both <sys/select.h> and <sys/time.h>
3429
(which you can't on SCO ODT 3.0).])
3432
AC_MSG_RESULT($was_it_defined)
3434
AC_MSG_CHECKING(for addrinfo)
3435
AC_CACHE_VAL(ac_cv_struct_addrinfo,
3436
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <netdb.h>]], [[struct addrinfo a]])],
3437
[ac_cv_struct_addrinfo=yes],
3438
[ac_cv_struct_addrinfo=no]))
3439
AC_MSG_RESULT($ac_cv_struct_addrinfo)
3440
if test $ac_cv_struct_addrinfo = yes; then
3441
AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
3444
AC_MSG_CHECKING(for sockaddr_storage)
3445
AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
3446
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3447
# include <sys/types.h>
3448
# include <sys/socket.h>]], [[struct sockaddr_storage s]])],
3449
[ac_cv_struct_sockaddr_storage=yes],
3450
[ac_cv_struct_sockaddr_storage=no]))
3451
AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
3452
if test $ac_cv_struct_sockaddr_storage = yes; then
3453
AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
3456
# checks for compiler characteristics
3462
AC_MSG_CHECKING(for working volatile)
3463
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[volatile int x; x = 0;]])],
3465
[AC_DEFINE(volatile, , [Define to empty if the keyword does not work.])]
3467
AC_MSG_RESULT($works)
3470
AC_MSG_CHECKING(for working signed char)
3471
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[signed char c;]])],
3473
[AC_DEFINE(signed, , [Define to empty if the keyword does not work.])]
3475
AC_MSG_RESULT($works)
3478
AC_MSG_CHECKING(for prototypes)
3479
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[int foo(int x) { return 0; }]], [[return foo(10);]])],
3480
[AC_DEFINE(HAVE_PROTOTYPES, 1,
3481
[Define if your compiler supports function prototype])
3482
have_prototypes=yes],
3485
AC_MSG_RESULT($have_prototypes)
3488
AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
3489
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3491
int foo(int x, ...) {
3499
]], [[return foo(10, "", 3.14);]])],[
3500
AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
3501
[Define if your compiler supports variable length function prototypes
3502
(e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
3505
AC_MSG_RESULT($works)
3507
# check for socketpair
3508
AC_MSG_CHECKING(for socketpair)
3509
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3510
#include <sys/types.h>
3511
#include <sys/socket.h>
3512
]], [[void *x=socketpair]])],
3513
[AC_DEFINE(HAVE_SOCKETPAIR, 1, [Define if you have the 'socketpair' function.])
3514
AC_MSG_RESULT(yes)],
3518
# check if sockaddr has sa_len member
3519
AC_MSG_CHECKING(if sockaddr has sa_len member)
3520
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
3521
#include <sys/socket.h>]], [[struct sockaddr x;
3524
AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member])],
3529
AC_MSG_CHECKING(whether va_list is an array)
3530
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3531
#ifdef HAVE_STDARG_PROTOTYPES
3534
#include <varargs.h>
3536
]], [[va_list list1, list2; list1 = list2;]])],[],[
3537
AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
3538
va_list_is_array=yes
3540
AC_MSG_RESULT($va_list_is_array)
3542
# sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
3543
AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
3544
[Define this if you have some version of gethostbyname_r()])
3546
AC_CHECK_FUNC(gethostbyname_r, [
3547
AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3548
AC_MSG_CHECKING([gethostbyname_r with 6 args])
3550
CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
3551
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3555
struct hostent *he, *res;
3560
(void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
3562
AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3563
AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
3564
[Define this if you have the 6-arg version of gethostbyname_r().])
3568
AC_MSG_CHECKING([gethostbyname_r with 5 args])
3569
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3578
(void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
3581
AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3582
AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
3583
[Define this if you have the 5-arg version of gethostbyname_r().])
3587
AC_MSG_CHECKING([gethostbyname_r with 3 args])
3588
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
3593
struct hostent_data data;
3595
(void) gethostbyname_r(name, he, &data);
3598
AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3599
AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
3600
[Define this if you have the 3-arg version of gethostbyname_r().])
3609
AC_CHECK_FUNCS(gethostbyname)
3611
AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
3612
AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
3613
AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
3614
AC_SUBST(HAVE_GETHOSTBYNAME_R)
3615
AC_SUBST(HAVE_GETHOSTBYNAME)
3617
# checks for system services
3620
# Linux requires this for correct f.p. operations
3621
AC_CHECK_FUNC(__fpu_control,
3623
[AC_CHECK_LIB(ieee, __fpu_control)
3626
# Check for --with-fpectl
3627
AC_MSG_CHECKING(for --with-fpectl)
3629
AS_HELP_STRING([--with-fpectl], [enable SIGFPE catching]),
3631
if test "$withval" != no
3633
AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
3634
[Define if you want SIGFPE handled (see Include/pyfpe.h).])
3636
else AC_MSG_RESULT(no)
3638
[AC_MSG_RESULT(no)])
3640
# check for --with-libm=...
3642
case $ac_sys_system in
3646
AC_MSG_CHECKING(for --with-libm=STRING)
3648
AS_HELP_STRING([--with-libm=STRING], [math library]),
3650
if test "$withval" = no
3652
AC_MSG_RESULT(force LIBM empty)
3653
elif test "$withval" != yes
3655
AC_MSG_RESULT(set LIBM="$withval")
3656
else AC_MSG_ERROR([proper usage is --with-libm=STRING])
3658
[AC_MSG_RESULT(default LIBM="$LIBM")])
3660
# check for --with-libc=...
3662
AC_MSG_CHECKING(for --with-libc=STRING)
3664
AS_HELP_STRING([--with-libc=STRING], [C library]),
3666
if test "$withval" = no
3668
AC_MSG_RESULT(force LIBC empty)
3669
elif test "$withval" != yes
3671
AC_MSG_RESULT(set LIBC="$withval")
3672
else AC_MSG_ERROR([proper usage is --with-libc=STRING])
3674
[AC_MSG_RESULT(default LIBC="$LIBC")])
3676
# **************************************
3677
# * Check for gcc x64 inline assembler *
3678
# **************************************
3680
AC_MSG_CHECKING(for x64 gcc inline assembler)
3681
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
3682
__asm__ __volatile__ ("movq %rcx, %rax");
3683
]])],[have_gcc_asm_for_x64=yes],[have_gcc_asm_for_x64=no])
3684
AC_MSG_RESULT($have_gcc_asm_for_x64)
3685
if test "$have_gcc_asm_for_x64" = yes
3687
AC_DEFINE(HAVE_GCC_ASM_FOR_X64, 1,
3688
[Define if we can use x64 gcc inline assembler])
3691
# **************************************************
3692
# * Check for various properties of floating point *
3693
# **************************************************
3695
AC_MSG_CHECKING(whether C doubles are little-endian IEEE 754 binary64)
3696
AC_CACHE_VAL(ac_cv_little_endian_double, [
3697
AC_RUN_IFELSE([AC_LANG_SOURCE([[
3700
double x = 9006104071832581.0;
3701
if (memcmp(&x, "\x05\x04\x03\x02\x01\xff\x3f\x43", 8) == 0)
3707
[ac_cv_little_endian_double=yes],
3708
[ac_cv_little_endian_double=no],
3709
[ac_cv_little_endian_double=no])])
3710
AC_MSG_RESULT($ac_cv_little_endian_double)
3711
if test "$ac_cv_little_endian_double" = yes
3713
AC_DEFINE(DOUBLE_IS_LITTLE_ENDIAN_IEEE754, 1,
3714
[Define if C doubles are 64-bit IEEE 754 binary format, stored
3715
with the least significant byte first])
3718
AC_MSG_CHECKING(whether C doubles are big-endian IEEE 754 binary64)
3719
AC_CACHE_VAL(ac_cv_big_endian_double, [
3720
AC_RUN_IFELSE([AC_LANG_SOURCE([[
3723
double x = 9006104071832581.0;
3724
if (memcmp(&x, "\x43\x3f\xff\x01\x02\x03\x04\x05", 8) == 0)
3730
[ac_cv_big_endian_double=yes],
3731
[ac_cv_big_endian_double=no],
3732
[ac_cv_big_endian_double=no])])
3733
AC_MSG_RESULT($ac_cv_big_endian_double)
3734
if test "$ac_cv_big_endian_double" = yes
3736
AC_DEFINE(DOUBLE_IS_BIG_ENDIAN_IEEE754, 1,
3737
[Define if C doubles are 64-bit IEEE 754 binary format, stored
3738
with the most significant byte first])
3741
# Some ARM platforms use a mixed-endian representation for doubles.
3742
# While Python doesn't currently have full support for these platforms
3743
# (see e.g., issue 1762561), we can at least make sure that float <-> string
3745
AC_MSG_CHECKING(whether C doubles are ARM mixed-endian IEEE 754 binary64)
3746
AC_CACHE_VAL(ac_cv_mixed_endian_double, [
3747
AC_RUN_IFELSE([AC_LANG_SOURCE([[
3750
double x = 9006104071832581.0;
3751
if (memcmp(&x, "\x01\xff\x3f\x43\x05\x04\x03\x02", 8) == 0)
3757
[ac_cv_mixed_endian_double=yes],
3758
[ac_cv_mixed_endian_double=no],
3759
[ac_cv_mixed_endian_double=no])])
3760
AC_MSG_RESULT($ac_cv_mixed_endian_double)
3761
if test "$ac_cv_mixed_endian_double" = yes
3763
AC_DEFINE(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754, 1,
3764
[Define if C doubles are 64-bit IEEE 754 binary format, stored
3765
in ARM mixed-endian order (byte order 45670123)])
3768
# The short float repr introduced in Python 3.1 requires the
3769
# correctly-rounded string <-> double conversion functions from
3770
# Python/dtoa.c, which in turn require that the FPU uses 53-bit
3771
# rounding; this is a problem on x86, where the x87 FPU has a default
3772
# rounding precision of 64 bits. For gcc/x86, we can fix this by
3773
# using inline assembler to get and set the x87 FPU control word.
3775
# This inline assembler syntax may also work for suncc and icc,
3776
# so we try it on all platforms.
3778
AC_MSG_CHECKING(whether we can use gcc inline assembler to get and set x87 control word)
3779
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
3781
__asm__ __volatile__ ("fnstcw %0" : "=m" (cw));
3782
__asm__ __volatile__ ("fldcw %0" : : "m" (cw));
3783
]])],[have_gcc_asm_for_x87=yes],[have_gcc_asm_for_x87=no])
3784
AC_MSG_RESULT($have_gcc_asm_for_x87)
3785
if test "$have_gcc_asm_for_x87" = yes
3787
AC_DEFINE(HAVE_GCC_ASM_FOR_X87, 1,
3788
[Define if we can use gcc inline assembler to get and set x87 control word])
3791
# Detect whether system arithmetic is subject to x87-style double
3792
# rounding issues. The result of this test has little meaning on non
3793
# IEEE 754 platforms. On IEEE 754, test should return 1 if rounding
3794
# mode is round-to-nearest and double rounding issues are present, and
3795
# 0 otherwise. See http://bugs.python.org/issue2937 for more info.
3796
AC_MSG_CHECKING(for x87-style double rounding)
3797
# $BASECFLAGS may affect the result
3799
CC="$CC $BASECFLAGS"
3800
AC_RUN_IFELSE([AC_LANG_SOURCE([[
3804
volatile double x, y, z;
3805
/* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */
3806
x = 0.99999999999999989; /* 1-2**-53 */
3810
/* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
3816
/* both tests show evidence of double rounding */
3820
[ac_cv_x87_double_rounding=no],
3821
[ac_cv_x87_double_rounding=yes],
3822
[ac_cv_x87_double_rounding=no])
3824
AC_MSG_RESULT($ac_cv_x87_double_rounding)
3825
if test "$ac_cv_x87_double_rounding" = yes
3827
AC_DEFINE(X87_DOUBLE_ROUNDING, 1,
3828
[Define if arithmetic is subject to x87-style double rounding issue])
3831
# ************************************
3832
# * Check for mathematical functions *
3833
# ************************************
3838
AC_CHECK_FUNCS([acosh asinh atanh copysign erf erfc expm1 finite gamma])
3839
AC_CHECK_FUNCS([hypot lgamma log1p log2 round tgamma])
3840
AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]])
3842
# On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
3843
# -0. on some architectures.
3844
AC_MSG_CHECKING(whether tanh preserves the sign of zero)
3845
AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
3846
AC_RUN_IFELSE([AC_LANG_SOURCE([[
3850
/* return 0 if either negative zeros don't exist
3851
on this platform or if negative zeros exist
3852
and tanh(-0.) == -0. */
3853
if (atan2(0., -1.) == atan2(-0., -1.) ||
3854
atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
3858
[ac_cv_tanh_preserves_zero_sign=yes],
3859
[ac_cv_tanh_preserves_zero_sign=no],
3860
[ac_cv_tanh_preserves_zero_sign=no])])
3861
AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
3862
if test "$ac_cv_tanh_preserves_zero_sign" = yes
3864
AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
3865
[Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
3868
if test "$ac_cv_func_log1p" = yes
3870
# On some versions of AIX, log1p(-0.) returns 0. instead of
3871
# -0. See issue #9920.
3872
AC_MSG_CHECKING(whether log1p drops the sign of negative zero)
3873
AC_CACHE_VAL(ac_cv_log1p_drops_zero_sign, [
3874
AC_RUN_IFELSE([AC_LANG_SOURCE([[
3878
/* Fail if the signs of log1p(-0.) and -0. can be
3880
if (atan2(log1p(-0.), -1.) == atan2(-0., -1.))
3886
[ac_cv_log1p_drops_zero_sign=no],
3887
[ac_cv_log1p_drops_zero_sign=yes],
3888
[ac_cv_log1p_drops_zero_sign=no])])
3889
AC_MSG_RESULT($ac_cv_log1p_drops_zero_sign)
3891
if test "$ac_cv_log1p_drops_zero_sign" = yes
3893
AC_DEFINE(LOG1P_DROPS_ZERO_SIGN, 1,
3894
[Define if log1p(-0.) is 0. rather than -0.])
3899
# For multiprocessing module, check that sem_open
3900
# actually works. For FreeBSD versions <= 7.2,
3901
# the kernel module that provides POSIX semaphores
3902
# isn't loaded by default, so an attempt to call
3903
# sem_open results in a 'Signal 12' error.
3904
AC_MSG_CHECKING(whether POSIX semaphores are enabled)
3905
AC_CACHE_VAL(ac_cv_posix_semaphores_enabled,
3906
AC_RUN_IFELSE([AC_LANG_SOURCE([[
3910
#include <semaphore.h>
3911
#include <sys/stat.h>
3914
sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR|S_IWUSR, 0);
3915
if (a == SEM_FAILED) {
3920
sem_unlink("/autoconf");
3924
[ac_cv_posix_semaphores_enabled=yes],
3925
[ac_cv_posix_semaphores_enabled=no],
3926
[ac_cv_posix_semaphores_enabled=yes])
3928
AC_MSG_RESULT($ac_cv_posix_semaphores_enabled)
3929
if test $ac_cv_posix_semaphores_enabled = no
3931
AC_DEFINE(POSIX_SEMAPHORES_NOT_ENABLED, 1,
3932
[Define if POSIX semaphores aren't enabled on your system])
3935
# Multiprocessing check for broken sem_getvalue
3936
AC_MSG_CHECKING(for broken sem_getvalue)
3937
AC_CACHE_VAL(ac_cv_broken_sem_getvalue,
3938
AC_RUN_IFELSE([AC_LANG_SOURCE([[
3942
#include <semaphore.h>
3943
#include <sys/stat.h>
3946
sem_t *a = sem_open("/autocftw", O_CREAT, S_IRUSR|S_IWUSR, 0);
3954
res = sem_getvalue(a, &count);
3956
sem_unlink("/autocftw");
3957
return res==-1 ? 1 : 0;
3960
[ac_cv_broken_sem_getvalue=no],
3961
[ac_cv_broken_sem_getvalue=yes],
3962
[ac_cv_broken_sem_getvalue=yes])
3964
AC_MSG_RESULT($ac_cv_broken_sem_getvalue)
3965
if test $ac_cv_broken_sem_getvalue = yes
3967
AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1,
3968
[define to 1 if your sem_getvalue is broken.])
3971
# determine what size digit to use for Python's longs
3972
AC_MSG_CHECKING([digit size for Python's longs])
3973
AC_ARG_ENABLE(big-digits,
3974
AS_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
3975
[case $enable_big_digits in
3977
enable_big_digits=30 ;;
3979
enable_big_digits=15 ;;
3983
AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
3985
AC_MSG_RESULT($enable_big_digits)
3986
AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits])
3988
[AC_MSG_RESULT(no value specified)])
3991
AC_CHECK_HEADER(wchar.h, [
3992
AC_DEFINE(HAVE_WCHAR_H, 1,
3993
[Define if the compiler provides a wchar.h header file.])
3999
# determine wchar_t size
4000
if test "$wchar_h" = yes
4002
AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
4005
AC_MSG_CHECKING(for UCS-4 tcl)
4007
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
4009
#if TCL_UTF_MAX != 6
4010
# error "NOT UCS4_TCL"
4012
AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
4015
AC_MSG_RESULT($have_ucs4_tcl)
4017
# check whether wchar_t is signed or not
4018
if test "$wchar_h" = yes
4020
# check whether wchar_t is signed or not
4021
AC_MSG_CHECKING(whether wchar_t is signed)
4022
AC_CACHE_VAL(ac_cv_wchar_t_signed, [
4023
AC_RUN_IFELSE([AC_LANG_SOURCE([[
4027
/* Success: exit code 0 */
4028
exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
4031
[ac_cv_wchar_t_signed=yes],
4032
[ac_cv_wchar_t_signed=no],
4033
[ac_cv_wchar_t_signed=yes])])
4034
AC_MSG_RESULT($ac_cv_wchar_t_signed)
4037
# wchar_t is only usable if it maps to an unsigned type
4038
if test "$ac_cv_sizeof_wchar_t" -ge 2 \
4039
-a "$ac_cv_wchar_t_signed" = "no"
4041
HAVE_USABLE_WCHAR_T="yes"
4042
AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
4043
[Define if you have a useable wchar_t type defined in wchar.h; useable
4044
means wchar_t must be an unsigned type with at least 16 bits. (see
4045
Include/unicodeobject.h).])
4047
HAVE_USABLE_WCHAR_T="no usable wchar_t found"
4049
AC_MSG_RESULT($HAVE_USABLE_WCHAR_T)
4051
# check for endianness
4054
# ABI version string for Python extension modules. This appears between the
4055
# periods in shared library file names, e.g. foo.<SOABI>.so. It is calculated
4056
# from the following attributes which affect the ABI of this Python build (in
4059
# * The Python implementation (always 'cpython-' for us)
4060
# * The major and minor version numbers
4061
# * --with-pydebug (adds a 'd')
4062
# * --with-pymalloc (adds a 'm')
4063
# * --with-wide-unicode (adds a 'u')
4065
# Thus for example, Python 3.2 built with wide unicode, pydebug, and pymalloc,
4066
# would get a shared library ABI version tag of 'cpython-32dmu' and shared
4067
# libraries would be named 'foo.cpython-32dmu.so'.
4069
AC_MSG_CHECKING(ABIFLAGS)
4070
AC_MSG_RESULT($ABIFLAGS)
4071
AC_MSG_CHECKING(SOABI)
4072
SOABI='cpython-'`echo $VERSION | tr -d .`${ABIFLAGS}
4073
AC_MSG_RESULT($SOABI)
4075
AC_SUBST(EXT_SUFFIX)
4076
case $ac_sys_system in
4078
EXT_SUFFIX=.${SOABI}${SHLIB_SUFFIX};;
4080
EXT_SUFFIX=${SHLIB_SUFFIX};;
4083
AC_MSG_CHECKING(LDVERSION)
4084
LDVERSION='$(VERSION)$(ABIFLAGS)'
4085
AC_MSG_RESULT($LDVERSION)
4087
dnl define LIBPL after ABIFLAGS and LDVERSION is defined.
4088
AC_SUBST(PY_ENABLE_SHARED)
4089
LIBPL="${prefix}/lib/python${VERSION}/config-${LDVERSION}"
4092
# Check whether right shifting a negative integer extends the sign bit
4093
# or fills with zeros (like the Cray J90, according to Tim Peters).
4094
AC_MSG_CHECKING(whether right shift extends the sign bit)
4095
AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
4096
AC_RUN_IFELSE([AC_LANG_SOURCE([[
4099
exit(((-1)>>3 == -1) ? 0 : 1);
4102
[ac_cv_rshift_extends_sign=yes],
4103
[ac_cv_rshift_extends_sign=no],
4104
[ac_cv_rshift_extends_sign=yes])])
4105
AC_MSG_RESULT($ac_cv_rshift_extends_sign)
4106
if test "$ac_cv_rshift_extends_sign" = no
4108
AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
4109
[Define if i>>j for signed int i does not extend the sign bit
4113
# check for getc_unlocked and related locking functions
4114
AC_MSG_CHECKING(for getc_unlocked() and friends)
4115
AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
4116
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>]], [[
4117
FILE *f = fopen("/dev/null", "r");
4121
]])],[ac_cv_have_getc_unlocked=yes],[ac_cv_have_getc_unlocked=no])])
4122
AC_MSG_RESULT($ac_cv_have_getc_unlocked)
4123
if test "$ac_cv_have_getc_unlocked" = yes
4125
AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
4126
[Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
4129
# check where readline lives
4130
# save the value of LIBS so we don't actually link Python with readline
4131
LIBS_no_readline=$LIBS
4133
# On some systems we need to link readline to a termcap compatible
4134
# library. NOTE: Keep the precedence of listed libraries synchronised
4136
py_cv_lib_readline=no
4137
AC_MSG_CHECKING([how to link readline libs])
4138
for py_libtermcap in "" tinfo ncursesw ncurses curses termcap; do
4139
if test -z "$py_libtermcap"; then
4140
READLINE_LIBS="-lreadline"
4142
READLINE_LIBS="-lreadline -l$py_libtermcap"
4144
LIBS="$READLINE_LIBS $LIBS_no_readline"
4146
[AC_LANG_CALL([],[readline])],
4147
[py_cv_lib_readline=yes])
4148
if test $py_cv_lib_readline = yes; then
4152
# Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
4153
#AC_SUBST([READLINE_LIBS])
4154
if test $py_cv_lib_readline = no; then
4155
AC_MSG_RESULT([none])
4157
AC_MSG_RESULT([$READLINE_LIBS])
4158
AC_DEFINE(HAVE_LIBREADLINE, 1,
4159
[Define if you have the readline library (-lreadline).])
4162
# check for readline 2.1
4163
AC_CHECK_LIB(readline, rl_callback_handler_install,
4164
AC_DEFINE(HAVE_RL_CALLBACK, 1,
4165
[Define if you have readline 2.1]), ,$READLINE_LIBS)
4167
# check for readline 2.2
4168
AC_PREPROC_IFELSE([AC_LANG_SOURCE([[#include <readline/readline.h>]])],
4169
[have_readline=yes],
4172
if test $have_readline = yes
4174
AC_EGREP_HEADER([extern int rl_completion_append_character;],
4175
[readline/readline.h],
4176
AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
4177
[Define if you have readline 2.2]), )
4178
AC_EGREP_HEADER([extern int rl_completion_suppress_append;],
4179
[readline/readline.h],
4180
AC_DEFINE(HAVE_RL_COMPLETION_SUPPRESS_APPEND, 1,
4181
[Define if you have rl_completion_suppress_append]), )
4184
# check for readline 4.0
4185
AC_CHECK_LIB(readline, rl_pre_input_hook,
4186
AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
4187
[Define if you have readline 4.0]), ,$READLINE_LIBS)
4190
AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
4191
AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
4192
[Define if you have readline 4.0]), ,$READLINE_LIBS)
4194
# check for readline 4.2
4195
AC_CHECK_LIB(readline, rl_completion_matches,
4196
AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
4197
[Define if you have readline 4.2]), ,$READLINE_LIBS)
4199
# also in readline 4.2
4200
AC_PREPROC_IFELSE([AC_LANG_SOURCE([[#include <readline/readline.h>]])],
4201
[have_readline=yes],
4204
if test $have_readline = yes
4206
AC_EGREP_HEADER([extern int rl_catch_signals;],
4207
[readline/readline.h],
4208
AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
4209
[Define if you can turn off readline's signal handling.]), )
4212
# End of readline checks: restore LIBS
4213
LIBS=$LIBS_no_readline
4215
AC_MSG_CHECKING(for broken nice())
4216
AC_CACHE_VAL(ac_cv_broken_nice, [
4217
AC_RUN_IFELSE([AC_LANG_SOURCE([[
4221
if (val1 != -1 && val1 == nice(2))
4226
[ac_cv_broken_nice=yes],
4227
[ac_cv_broken_nice=no],
4228
[ac_cv_broken_nice=no])])
4229
AC_MSG_RESULT($ac_cv_broken_nice)
4230
if test "$ac_cv_broken_nice" = yes
4232
AC_DEFINE(HAVE_BROKEN_NICE, 1,
4233
[Define if nice() returns success/failure instead of the new priority.])
4236
AC_MSG_CHECKING(for broken poll())
4237
AC_CACHE_VAL(ac_cv_broken_poll,
4238
AC_RUN_IFELSE([AC_LANG_SOURCE([[
4243
struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
4248
poll_test = poll(&poll_struct, 1, 0);
4251
else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
4257
[ac_cv_broken_poll=yes],
4258
[ac_cv_broken_poll=no],
4259
[ac_cv_broken_poll=no]))
4260
AC_MSG_RESULT($ac_cv_broken_poll)
4261
if test "$ac_cv_broken_poll" = yes
4263
AC_DEFINE(HAVE_BROKEN_POLL, 1,
4264
[Define if poll() sets errno on invalid file descriptors.])
4267
# Before we can test tzset, we need to check if struct tm has a tm_zone
4268
# (which is not required by ISO C or UNIX spec) and/or if we support
4272
# check tzset(3) exists and works like we expect it to
4273
AC_MSG_CHECKING(for working tzset())
4274
AC_CACHE_VAL(ac_cv_working_tzset, [
4275
AC_RUN_IFELSE([AC_LANG_SOURCE([[
4281
extern char *tzname[];
4286
/* Note that we need to ensure that not only does tzset(3)
4287
do 'something' with localtime, but it works as documented
4288
in the library reference and as expected by the test suite.
4289
This includes making sure that tzname is set properly if
4290
tm->tm_zone does not exist since it is the alternative way
4291
of getting timezone info.
4293
Red Hat 6.2 doesn't understand the southern hemisphere
4294
after New Year's Day.
4297
time_t groundhogday = 1044144000; /* GMT-based */
4298
time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
4302
if (localtime(&groundhogday)->tm_hour != 0)
4305
/* For UTC, tzname[1] is sometimes "", sometimes " " */
4306
if (strcmp(tzname[0], "UTC") ||
4307
(tzname[1][0] != 0 && tzname[1][0] != ' '))
4311
putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
4313
if (localtime(&groundhogday)->tm_hour != 19)
4316
if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
4320
putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
4322
if (localtime(&groundhogday)->tm_hour != 11)
4325
if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
4329
#if HAVE_STRUCT_TM_TM_ZONE
4330
if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
4332
if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
4339
[ac_cv_working_tzset=yes],
4340
[ac_cv_working_tzset=no],
4341
[ac_cv_working_tzset=no])])
4342
AC_MSG_RESULT($ac_cv_working_tzset)
4343
if test "$ac_cv_working_tzset" = yes
4345
AC_DEFINE(HAVE_WORKING_TZSET, 1,
4346
[Define if tzset() actually switches the local timezone in a meaningful way.])
4349
# Look for subsecond timestamps in struct stat
4350
AC_MSG_CHECKING(for tv_nsec in struct stat)
4351
AC_CACHE_VAL(ac_cv_stat_tv_nsec,
4352
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/stat.h>]], [[
4354
st.st_mtim.tv_nsec = 1;
4356
[ac_cv_stat_tv_nsec=yes],
4357
[ac_cv_stat_tv_nsec=no]))
4358
AC_MSG_RESULT($ac_cv_stat_tv_nsec)
4359
if test "$ac_cv_stat_tv_nsec" = yes
4361
AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
4362
[Define if you have struct stat.st_mtim.tv_nsec])
4365
# Look for BSD style subsecond timestamps in struct stat
4366
AC_MSG_CHECKING(for tv_nsec2 in struct stat)
4367
AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
4368
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/stat.h>]], [[
4370
st.st_mtimespec.tv_nsec = 1;
4372
[ac_cv_stat_tv_nsec2=yes],
4373
[ac_cv_stat_tv_nsec2=no]))
4374
AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
4375
if test "$ac_cv_stat_tv_nsec2" = yes
4377
AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
4378
[Define if you have struct stat.st_mtimensec])
4381
ac_save_cppflags="$CPPFLAGS"
4382
CPPFLAGS="$CPPFLAGS -I/usr/include/ncursesw"
4383
# On HP/UX 11.0, mvwdelch is a block with a return statement
4384
AC_MSG_CHECKING(whether mvwdelch is an expression)
4385
AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
4386
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
4388
rtn = mvwdelch(0,0,0);
4390
[ac_cv_mvwdelch_is_expression=yes],
4391
[ac_cv_mvwdelch_is_expression=no]))
4392
AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
4394
if test "$ac_cv_mvwdelch_is_expression" = yes
4396
AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
4397
[Define if mvwdelch in curses.h is an expression.])
4400
AC_MSG_CHECKING(whether WINDOW has _flags)
4401
AC_CACHE_VAL(ac_cv_window_has_flags,
4402
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
4406
[ac_cv_window_has_flags=yes],
4407
[ac_cv_window_has_flags=no]))
4408
AC_MSG_RESULT($ac_cv_window_has_flags)
4411
if test "$ac_cv_window_has_flags" = yes
4413
AC_DEFINE(WINDOW_HAS_FLAGS, 1,
4414
[Define if WINDOW in curses.h offers a field _flags.])
4417
AC_MSG_CHECKING(for is_term_resized)
4418
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=is_term_resized]])],
4419
[AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
4420
AC_MSG_RESULT(yes)],
4424
AC_MSG_CHECKING(for resize_term)
4425
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=resize_term]])],
4426
[AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
4427
AC_MSG_RESULT(yes)],
4431
AC_MSG_CHECKING(for resizeterm)
4432
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=resizeterm]])],
4433
[AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
4434
AC_MSG_RESULT(yes)],
4437
# last curses configure check
4438
CPPFLAGS=$ac_save_cppflags
4440
AC_MSG_NOTICE([checking for device files])
4442
dnl NOTE: Inform user how to proceed with files when cross compiling.
4443
if test "x$cross_compiling" = xyes; then
4444
if test "${ac_cv_file__dev_ptmx+set}" != set; then
4445
AC_MSG_CHECKING([for /dev/ptmx])
4446
AC_MSG_RESULT([not set])
4447
AC_MSG_ERROR([set ac_cv_file__dev_ptmx to yes/no in your CONFIG_SITE file when cross compiling])
4449
if test "${ac_cv_file__dev_ptc+set}" != set; then
4450
AC_MSG_CHECKING([for /dev/ptc])
4451
AC_MSG_RESULT([not set])
4452
AC_MSG_ERROR([set ac_cv_file__dev_ptc to yes/no in your CONFIG_SITE file when cross compiling])
4456
AC_CHECK_FILE(/dev/ptmx, [], [])
4457
if test "x$ac_cv_file__dev_ptmx" = xyes; then
4458
AC_DEFINE(HAVE_DEV_PTMX, 1,
4459
[Define to 1 if you have the /dev/ptmx device file.])
4461
AC_CHECK_FILE(/dev/ptc, [], [])
4462
if test "x$ac_cv_file__dev_ptc" = xyes; then
4463
AC_DEFINE(HAVE_DEV_PTC, 1,
4464
[Define to 1 if you have the /dev/ptc device file.])
4467
if test "$have_long_long" = yes
4469
AC_MSG_CHECKING(for %lld and %llu printf() format support)
4470
AC_CACHE_VAL(ac_cv_have_long_long_format,
4471
AC_RUN_IFELSE([AC_LANG_SOURCE([[[
4476
#ifdef HAVE_SYS_TYPES_H
4477
#include <sys/types.h>
4484
if (sprintf(buffer, "%lld", (long long)123) < 0)
4486
if (strcmp(buffer, "123"))
4489
if (sprintf(buffer, "%lld", (long long)-123) < 0)
4491
if (strcmp(buffer, "-123"))
4494
if (sprintf(buffer, "%llu", (unsigned long long)123) < 0)
4496
if (strcmp(buffer, "123"))
4502
[ac_cv_have_long_long_format=yes],
4503
[ac_cv_have_long_long_format=no],
4504
[ac_cv_have_long_long_format="cross -- assuming no"
4505
if test x$GCC = xyes; then
4507
CFLAGS="$CFLAGS -Werror -Wformat"
4508
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
4513
sprintf(buffer, "%lld", (long long)123);
4514
sprintf(buffer, "%lld", (long long)-123);
4515
sprintf(buffer, "%llu", (unsigned long long)123);
4517
ac_cv_have_long_long_format=yes
4522
AC_MSG_RESULT($ac_cv_have_long_long_format)
4525
if test "$ac_cv_have_long_long_format" = yes
4527
AC_DEFINE(PY_FORMAT_LONG_LONG, "ll",
4528
[Define to printf format modifier for long long type])
4531
if test $ac_sys_system = Darwin
4533
LIBS="$LIBS -framework CoreFoundation"
4536
AC_CACHE_CHECK([for %zd printf() format support], ac_cv_have_size_t_format, [dnl
4537
AC_RUN_IFELSE([AC_LANG_SOURCE([[
4542
#ifdef HAVE_SYS_TYPES_H
4543
#include <sys/types.h>
4547
typedef ssize_t Py_ssize_t;
4548
#elif SIZEOF_VOID_P == SIZEOF_LONG
4549
typedef long Py_ssize_t;
4551
typedef int Py_ssize_t;
4558
if(sprintf(buffer, "%zd", (size_t)123) < 0)
4561
if (strcmp(buffer, "123"))
4564
if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
4567
if (strcmp(buffer, "-123"))
4573
[ac_cv_have_size_t_format=yes],
4574
[ac_cv_have_size_t_format=no],
4575
[ac_cv_have_size_t_format="cross -- assuming yes"
4577
if test "$ac_cv_have_size_t_format" != no ; then
4578
AC_DEFINE(PY_FORMAT_SIZE_T, "z",
4579
[Define to printf format modifier for Py_ssize_t])
4582
AC_CHECK_TYPE(socklen_t,,
4583
AC_DEFINE(socklen_t,int,
4584
[Define to `int' if <sys/socket.h> does not define.]),[
4585
#ifdef HAVE_SYS_TYPES_H
4586
#include <sys/types.h>
4588
#ifdef HAVE_SYS_SOCKET_H
4589
#include <sys/socket.h>
4593
AC_MSG_CHECKING(for broken mbstowcs)
4594
AC_CACHE_VAL(ac_cv_broken_mbstowcs,
4595
AC_RUN_IFELSE([AC_LANG_SOURCE([[
4600
const char *str = "text";
4601
len = mbstowcs(NULL, str, 0);
4605
[ac_cv_broken_mbstowcs=no],
4606
[ac_cv_broken_mbstowcs=yes],
4607
[ac_cv_broken_mbstowcs=no]))
4608
AC_MSG_RESULT($ac_cv_broken_mbstowcs)
4609
if test "$ac_cv_broken_mbstowcs" = yes
4611
AC_DEFINE(HAVE_BROKEN_MBSTOWCS, 1,
4612
[Define if mbstowcs(NULL, "text", 0) does not return the number of
4613
wide chars that would be converted.])
4616
# Check for --with-computed-gotos
4617
AC_MSG_CHECKING(for --with-computed-gotos)
4618
AC_ARG_WITH(computed-gotos,
4619
AS_HELP_STRING([--with(out)-computed-gotos],
4620
[Use computed gotos in evaluation loop (enabled by default on supported compilers)]),
4622
if test "$withval" = yes
4624
AC_DEFINE(USE_COMPUTED_GOTOS, 1,
4625
[Define if you want to use computed gotos in ceval.c.])
4628
if test "$withval" = no
4630
AC_DEFINE(USE_COMPUTED_GOTOS, 0,
4631
[Define if you want to use computed gotos in ceval.c.])
4635
[AC_MSG_RESULT(no value specified)])
4637
AC_MSG_CHECKING(whether $CC supports computed gotos)
4638
AC_CACHE_VAL(ac_cv_computed_gotos,
4639
AC_RUN_IFELSE([AC_LANG_SOURCE([[[
4640
int main(int argc, char **argv)
4642
static void *targets[1] = { &&LABEL1 };
4651
[ac_cv_computed_gotos=yes],
4652
[ac_cv_computed_gotos=no],
4653
[if test "${with_computed_gotos+set}" = set; then
4654
ac_cv_computed_gotos="$with_computed_gotos -- configured --with(out)-computed-gotos"
4656
ac_cv_computed_gotos=no
4658
AC_MSG_RESULT($ac_cv_computed_gotos)
4659
case "$ac_cv_computed_gotos" in yes*)
4660
AC_DEFINE(HAVE_COMPUTED_GOTOS, 1,
4661
[Define if the C compiler supports computed gotos.])
4664
case $ac_sys_system in
4666
AC_DEFINE(HAVE_BROKEN_PIPE_BUF, 1, [Define if the system reports an invalid PIPE_BUF value.]) ;;
4670
AC_SUBST(THREADHEADERS)
4672
for h in `(cd $srcdir;echo Python/thread_*.h)`
4674
THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
4678
SRCDIRS="Parser Grammar Objects Python Modules Mac"
4679
AC_MSG_CHECKING(for build directories)
4680
for dir in $SRCDIRS; do
4681
if test ! -d $dir; then
4687
# Availability of -O2:
4688
AC_MSG_CHECKING(for -O2)
4689
saved_cflags="$CFLAGS"
4691
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
4692
]])],[have_O2=yes],[have_O2=no])
4693
AC_MSG_RESULT($have_O2)
4694
CFLAGS="$saved_cflags"
4696
# _FORTIFY_SOURCE wrappers for memmove and bcopy are incorrect:
4697
# http://sourceware.org/ml/libc-alpha/2010-12/msg00009.html
4698
AC_MSG_CHECKING(for glibc _FORTIFY_SOURCE/memmove bug)
4699
saved_cflags="$CFLAGS"
4700
CFLAGS="-O2 -D_FORTIFY_SOURCE=2"
4701
if test "$have_O2" = no; then
4704
AC_RUN_IFELSE([AC_LANG_SOURCE([[
4708
void foo(void *p, void *q) { memmove(p, q, 19); }
4710
char a[32] = "123456789000000000";
4712
if (strcmp(a, "123456789123456789000000000") != 0)
4715
if (strcmp(a, "123456789000000000") != 0)
4720
[have_glibc_memmove_bug=no],
4721
[have_glibc_memmove_bug=yes],
4722
[have_glibc_memmove_bug=undefined])
4723
CFLAGS="$saved_cflags"
4724
AC_MSG_RESULT($have_glibc_memmove_bug)
4725
if test "$have_glibc_memmove_bug" = yes; then
4726
AC_DEFINE(HAVE_GLIBC_MEMMOVE_BUG, 1,
4727
[Define if glibc has incorrect _FORTIFY_SOURCE wrappers
4728
for memmove and bcopy.])
4731
if test "$have_gcc_asm_for_x87" = yes; then
4732
# Some versions of gcc miscompile inline asm:
4733
# http://gcc.gnu.org/bugzilla/show_bug.cgi?id=46491
4734
# http://gcc.gnu.org/ml/gcc/2010-11/msg00366.html
4737
AC_MSG_CHECKING(for gcc ipa-pure-const bug)
4738
saved_cflags="$CFLAGS"
4740
AC_RUN_IFELSE([AC_LANG_SOURCE([[
4741
__attribute__((noinline)) int
4744
asm ( "movl \$6, (%1)\n\t"
4746
: "=r" (r) : "r" (p) : "memory"
4752
if ((foo(&p) ? : p) != 6)
4757
[have_ipa_pure_const_bug=no],
4758
[have_ipa_pure_const_bug=yes],
4759
[have_ipa_pure_const_bug=undefined])
4760
CFLAGS="$saved_cflags"
4761
AC_MSG_RESULT($have_ipa_pure_const_bug)
4762
if test "$have_ipa_pure_const_bug" = yes; then
4763
AC_DEFINE(HAVE_IPA_PURE_CONST_BUG, 1,
4764
[Define if gcc has the ipa-pure-const bug.])
4771
AC_MSG_CHECKING(for ensurepip)
4772
AC_ARG_WITH(ensurepip,
4773
[AS_HELP_STRING([--with(out)-ensurepip=@<:@=upgrade@:>@],
4774
["install" or "upgrade" using bundled pip])],
4776
[with_ensurepip=upgrade])
4777
AS_CASE($with_ensurepip,
4778
[yes|upgrade],[ENSUREPIP=upgrade],
4779
[install],[ENSUREPIP=install],
4780
[no],[ENSUREPIP=no],
4781
[AC_MSG_ERROR([--with-ensurepip=upgrade|install|no])])
4782
AC_MSG_RESULT($ENSUREPIP)
4785
# generate output files
4786
AC_CONFIG_FILES(Makefile.pre Modules/Setup.config Misc/python.pc Misc/python-config.sh)
4787
AC_CONFIG_FILES([Modules/ld_so_aix], [chmod +x Modules/ld_so_aix])
4790
echo "creating Modules/Setup" >&AS_MESSAGE_FD
4791
if test ! -f Modules/Setup
4793
cp $srcdir/Modules/Setup.dist Modules/Setup
4796
echo "creating Modules/Setup.local" >&AS_MESSAGE_FD
4797
if test ! -f Modules/Setup.local
4799
echo "# Edit this file for local setup changes" >Modules/Setup.local
4802
echo "creating Makefile" >&AS_MESSAGE_FD
4803
$SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
4804
-s Modules Modules/Setup.config \
4805
Modules/Setup.local Modules/Setup
added
removed
configure.ac
