1 dnl ***********************************************
2 dnl * Please run autoreconf to test your changes! *
3 dnl ***********************************************
4 dnl NOTE: autoconf 2.64 doesn't seem to work (use 2.61).
6 # Set VERSION so we only need to edit in one place (i.e., here)
7 m4_define(PYTHON_VERSION, 2.7)
9 dnl Some m4 magic to ensure that the configure script is generated
10 dnl by the correct autoconf version.
11 m4_define([version_required],
12 [m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]), [$1]), 0,
14 [m4_fatal([Autoconf version $1 is required for Python], 63)])
16 version_required(2.61)
18 AC_REVISION($Revision$)
19 AC_INIT(python, PYTHON_VERSION, http://bugs.python.org/)
20 AC_CONFIG_SRCDIR([Include/object.h])
21 AC_CONFIG_HEADER(pyconfig.h)
23 dnl Ensure that if prefix is specified, it does not end in a slash. If
24 dnl it does, we get path names containing '//' which is both ugly and
25 dnl can cause trouble.
27 dnl Last slash shouldn't be stripped if prefix=/
28 if test "$prefix" != "/"; then
29 prefix=`echo "$prefix" | sed -e 's/\/$//g'`
32 dnl This is for stuff that absolutely must end up in pyconfig.h.
33 dnl Please use pyport.h instead, if possible.
39 /* Define the macros needed if on a UnixWare 7.x system. */
40 #if defined(__USLC__) && defined(__SCO_VERSION__)
41 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
44 #endif /*Py_PYCONFIG_H*/
47 # We don't use PACKAGE_ variables, and they cause conflicts
48 # with other autoconf-based packages that include Python.h
49 grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
51 mv confdefs.h.new confdefs.h
54 VERSION=PYTHON_VERSION
59 # The later defininition of _XOPEN_SOURCE disables certain features
60 # on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
61 AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])
63 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
64 # certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
66 AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])
68 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
69 # certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
71 AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])
73 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
74 # u_int on Irix 5.3. Defining _BSD_TYPES brings it back.
75 AC_DEFINE(_BSD_TYPES, 1, [Define on Irix to enable u_int])
77 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
78 # certain features on Mac OS X, so we need _DARWIN_C_SOURCE to re-enable
80 AC_DEFINE(_DARWIN_C_SOURCE, 1, [Define on Darwin to activate all library features])
83 define_xopen_source=yes
85 # Arguments passed to configure.
87 CONFIG_ARGS="$ac_configure_args"
89 AC_ARG_ENABLE(universalsdk,
90 AC_HELP_STRING(--enable-universalsdk@<:@=SDKDIR@:>@, Build against Mac OS X 10.4u SDK (ppc/i386)),
94 enableval=/Developer/SDKs/MacOSX10.4u.sdk
103 UNIVERSALSDK=$enableval
110 AC_SUBST(UNIVERSALSDK)
112 AC_SUBST(ARCH_RUN_32BIT)
114 UNIVERSAL_ARCHS="32-bit"
115 AC_MSG_CHECKING(for --with-universal-archs)
116 AC_ARG_WITH(universal-archs,
117 AC_HELP_STRING(--with-universal-archs=ARCH, select architectures for universal build ("32-bit", "64-bit", "3-way", "intel" or "all")),
119 AC_MSG_RESULT($withval)
120 UNIVERSAL_ARCHS="$withval"
123 AC_MSG_RESULT(32-bit)
128 AC_ARG_WITH(framework-name,
129 AC_HELP_STRING(--with-framework-name=FRAMEWORK,
130 specify an alternate name of the framework built with --enable-framework),
132 PYTHONFRAMEWORK=${withval}
133 PYTHONFRAMEWORKDIR=${withval}.framework
134 PYTHONFRAMEWORKIDENTIFIER=org.python.`echo $withval | tr '[A-Z]' '[a-z]'`
136 PYTHONFRAMEWORK=Python
137 PYTHONFRAMEWORKDIR=Python.framework
138 PYTHONFRAMEWORKIDENTIFIER=org.python.python
140 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
141 AC_ARG_ENABLE(framework,
142 AC_HELP_STRING(--enable-framework@<:@=INSTALLDIR@:>@, Build (MacOSX|Darwin) framework),
146 enableval=/Library/Frameworks
151 PYTHONFRAMEWORKDIR=no-framework
152 PYTHONFRAMEWORKPREFIX=
153 PYTHONFRAMEWORKINSTALLDIR=
154 FRAMEWORKINSTALLFIRST=
155 FRAMEWORKINSTALLLAST=
156 FRAMEWORKALTINSTALLFIRST=
157 FRAMEWORKALTINSTALLLAST=
158 if test "x${prefix}" = "xNONE"; then
159 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
161 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
166 PYTHONFRAMEWORKPREFIX=$enableval
167 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
168 FRAMEWORKINSTALLFIRST="frameworkinstallstructure"
169 FRAMEWORKALTINSTALLFIRST="frameworkinstallstructure bininstall maninstall"
170 if test "$UNIVERSAL_ARCHS" = "all"
172 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps4way frameworkinstallunixtools4way"
173 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps4way frameworkaltinstallunixtools4way"
175 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools"
176 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkaltinstallunixtools"
179 if test "x${prefix}" = "xNONE" ; then
180 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
182 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
184 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
186 # Add files for Mac specific code to the list of output
188 AC_CONFIG_FILES(Mac/Makefile)
189 AC_CONFIG_FILES(Mac/PythonLauncher/Makefile)
190 AC_CONFIG_FILES(Mac/IDLE/Makefile)
191 AC_CONFIG_FILES(Mac/Resources/framework/Info.plist)
192 AC_CONFIG_FILES(Mac/Resources/app/Info.plist)
196 PYTHONFRAMEWORKDIR=no-framework
197 PYTHONFRAMEWORKPREFIX=
198 PYTHONFRAMEWORKINSTALLDIR=
199 FRAMEWORKINSTALLFIRST=
200 FRAMEWORKINSTALLLAST=
201 FRAMEWORKALTINSTALLFIRST=
202 FRAMEWORKALTINSTALLLAST=
203 if test "x${prefix}" = "xNONE" ; then
204 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
206 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
210 if test "$UNIVERSAL_ARCHS" = "all"
212 FRAMEWORKINSTALLLAST=update4wayuniversal
213 FRAMEWORKALTINSTALLLAST=update4wayuniversal
216 AC_SUBST(PYTHONFRAMEWORK)
217 AC_SUBST(PYTHONFRAMEWORKIDENTIFIER)
218 AC_SUBST(PYTHONFRAMEWORKDIR)
219 AC_SUBST(PYTHONFRAMEWORKPREFIX)
220 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
221 AC_SUBST(FRAMEWORKINSTALLFIRST)
222 AC_SUBST(FRAMEWORKINSTALLLAST)
223 AC_SUBST(FRAMEWORKALTINSTALLFIRST)
224 AC_SUBST(FRAMEWORKALTINSTALLLAST)
225 AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX)
228 ## AC_HELP_STRING(--with-dyld,
229 ## Use (OpenStep|Rhapsody) dynamic linker))
231 # Set name for machine-dependent library files
233 AC_MSG_CHECKING(MACHDEP)
234 if test -z "$MACHDEP"
236 ac_sys_system=`uname -s`
237 if test "$ac_sys_system" = "AIX" \
238 -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
239 ac_sys_release=`uname -v`
241 ac_sys_release=`uname -r`
243 ac_md_system=`echo $ac_sys_system |
244 tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
245 ac_md_release=`echo $ac_sys_release |
246 tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
247 MACHDEP="$ac_md_system$ac_md_release"
250 cygwin*) MACHDEP="cygwin";;
251 darwin*) MACHDEP="darwin";;
252 atheos*) MACHDEP="atheos";;
253 irix646) MACHDEP="irix6";;
254 '') MACHDEP="unknown";;
258 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
259 # disable features if it is defined, without any means to access these
260 # features as extensions. For these systems, we skip the definition of
261 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
262 # some feature, make sure there is no alternative way to access this
263 # feature. Also, when using wildcards, make sure you have verified the
264 # need for not defining _XOPEN_SOURCE on all systems matching the
265 # wildcard, and that the wildcard does not include future systems
266 # (which may remove their limitations).
267 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
268 case $ac_sys_system/$ac_sys_release in
269 # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
270 # even though select is a POSIX function. Reported by J. Ribbens.
271 # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
272 OpenBSD/2.* | OpenBSD/3.@<:@0123456789@:>@ | OpenBSD/4.@<:@0123@:>@)
273 define_xopen_source=no
274 # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
275 # also defined. This can be overridden by defining _BSD_SOURCE
276 # As this has a different meaning on Linux, only define it on OpenBSD
277 AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
279 # Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
280 # _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
282 NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6@<:@A-S@:>@)
283 define_xopen_source=no;;
284 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
285 # of union __?sigval. Reported by Stuart Bishop.
287 define_xopen_source=no;;
288 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
289 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
290 # Reconfirmed for 7.1.4 by Martin v. Loewis.
291 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
292 define_xopen_source=no;;
293 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
294 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
296 define_xopen_source=no;;
297 # On FreeBSD 4, the math functions C89 does not cover are never defined
298 # with _XOPEN_SOURCE and __BSD_VISIBLE does not re-enable them.
300 define_xopen_source=no;;
301 # On MacOS X 10.2, a bug in ncurses.h means that it craps out if
302 # _XOPEN_EXTENDED_SOURCE is defined. Apparently, this is fixed in 10.3, which
303 # identifies itself as Darwin/7.*
304 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
305 # disables platform specific features beyond repair.
306 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
307 # has no effect, don't bother defining them
308 Darwin/@<:@6789@:>@.*)
309 define_xopen_source=no;;
310 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
311 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
312 # or has another value. By not (re)defining it, the defaults come in place.
314 define_xopen_source=no;;
316 if test `uname -r` -eq 1; then
317 define_xopen_source=no
320 # On QNX 6.3.2, defining _XOPEN_SOURCE prevents netdb.h from
321 # defining NI_NUMERICHOST.
323 define_xopen_source=no
328 if test $define_xopen_source = yes
330 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
331 # defined precisely as g++ defines it
332 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
334 case $ac_sys_system/$ac_sys_release in
335 SunOS/5.8|SunOS/5.9|SunOS/5.10)
336 AC_DEFINE(_XOPEN_SOURCE, 500,
337 Define to the level of X/Open that your system supports)
340 AC_DEFINE(_XOPEN_SOURCE, 600,
341 Define to the level of X/Open that your system supports)
345 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
346 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
347 # several APIs are not declared. Since this is also needed in some
348 # cases for HP-UX, we define it globally.
349 # except for Solaris 10, where it must not be defined,
350 # as it implies XPG4.2
351 case $ac_sys_system/$ac_sys_release in
355 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
356 Define to activate Unix95-and-earlier features)
360 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
365 # SGI compilers allow the specification of the both the ABI and the
366 # ISA on the command line. Depending on the values of these switches,
367 # different and often incompatable code will be generated.
369 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
370 # thus supply support for various ABI/ISA combinations. The MACHDEP
371 # variable is also adjusted.
374 if test ! -z "$SGI_ABI"
377 LDFLAGS="$SGI_ABI $LDFLAGS"
378 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
380 AC_MSG_RESULT($MACHDEP)
382 # And add extra plat-mac for darwin
383 AC_SUBST(EXTRAPLATDIR)
384 AC_SUBST(EXTRAMACHDEPPATH)
385 AC_MSG_CHECKING(EXTRAPLATDIR)
386 if test -z "$EXTRAPLATDIR"
390 EXTRAPLATDIR="\$(PLATMACDIRS)"
391 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
399 AC_MSG_RESULT($EXTRAPLATDIR)
401 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
402 # it may influence the way we can build extensions, so distutils
404 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
405 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
406 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
407 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
409 AC_MSG_CHECKING(machine type as reported by uname -m)
410 ac_sys_machine=`uname -m`
411 AC_MSG_RESULT($ac_sys_machine)
413 # checks for alternative programs
415 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
416 # for debug/optimization stuff. BASECFLAGS is for flags that are required
417 # just to get things to compile and link. Users are free to override OPT
418 # when running configure or make. The build should not break if they do.
419 # BASECFLAGS should generally not be messed with, however.
421 # XXX shouldn't some/most/all of this code be merged with the stuff later
422 # on that fiddles with OPT and BASECFLAGS?
423 AC_MSG_CHECKING(for --without-gcc)
425 AC_HELP_STRING(--without-gcc,never use gcc),
433 without_gcc=$withval;;
435 case $ac_sys_system in
443 BASECFLAGS="$BASECFLAGS -export pragma"
445 LDFLAGS="$LDFLAGS -nodup"
453 AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
456 AR="\$(srcdir)/Modules/ar_beos"
461 AC_MSG_RESULT($without_gcc)
463 # If the user switches compilers, we can't believe the cache
464 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
466 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
467 (it is also a good idea to do 'make clean' before compiling)])
474 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
475 AC_ARG_WITH(cxx_main,
476 AC_HELP_STRING([--with-cxx-main=<compiler>],
477 [compile main() and link python executable with C++ compiler]),
483 yes) with_cxx_main=yes
495 AC_MSG_RESULT($with_cxx_main)
501 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
502 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
504 if test "$CXX" = "notfound"
511 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
512 if test "$CXX" = "notfound"
517 if test "$preset_cxx" != "$CXX"
521 By default, distutils will build C++ extension modules with "$CXX".
522 If this is not intended, then set CXX on the configure command line.
527 # checks for UNIX variants that set C preprocessor variables
530 # Check for unsupported systems
531 case $ac_sys_system/$ac_sys_release in
533 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
534 echo See README for details.
539 AC_MSG_CHECKING(for --with-suffix)
541 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
548 AC_MSG_RESULT($EXEEXT)
550 # Test whether we're running on a non-case-sensitive system, in which
551 # case we give a warning if no ext is given
552 AC_SUBST(BUILDEXEEXT)
553 AC_MSG_CHECKING(for case-insensitive build directory)
554 if test ! -d CaseSensitiveTestDir; then
555 mkdir CaseSensitiveTestDir
558 if test -d casesensitivetestdir
566 rmdir CaseSensitiveTestDir
571 gcc) CC="$CC -D_HAVE_BSDI";;
575 case $ac_sys_system in
578 cc|*/cc) CC="$CC -Ae";;
581 # Some functions have a prototype only with that define, e.g. confstr
582 AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
588 AC_MSG_CHECKING(LIBRARY)
589 if test -z "$LIBRARY"
591 LIBRARY='libpython$(VERSION).a'
593 AC_MSG_RESULT($LIBRARY)
595 # LDLIBRARY is the name of the library to link against (as opposed to the
596 # name of the library into which to insert object files). BLDLIBRARY is also
597 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
598 # is blank as the main program is not linked directly against LDLIBRARY.
599 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
600 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
601 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
602 # DLLLIBRARY is the shared (i.e., DLL) library.
604 # RUNSHARED is used to run shared python without installed libraries
606 # INSTSONAME is the name of the shared library that will be use to install
607 # on the system - some systems like version suffix, others don't
611 AC_SUBST(LDLIBRARYDIR)
615 BLDLIBRARY='$(LDLIBRARY)'
616 INSTSONAME='$(LDLIBRARY)'
621 # LINKCC is the command that links the python executable -- default is $(CC).
622 # If CXX is set, and if it is needed to link a main function that was
623 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
624 # python might then depend on the C++ runtime
625 # This is altered for AIX in order to build the export list before
628 AC_MSG_CHECKING(LINKCC)
631 LINKCC='$(PURIFY) $(MAINCC)'
632 case $ac_sys_system in
635 if test $ac_sys_release -ge 5 -o \
636 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
639 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
641 # qcc must be used because the other compilers do not
646 AC_MSG_RESULT($LINKCC)
648 # GNULD is set to "yes" if the GNU linker is used. If this goes wrong
649 # make sure we default having it set to "no": this is used by
650 # distutils.unixccompiler to know if it should add --enable-new-dtags
651 # to linker command lines, and failing to detect GNU ld simply results
652 # in the same bahaviour as before.
654 AC_MSG_CHECKING(for GNU ld)
656 if test "$GCC" = yes; then
657 ac_prog=`$CC -print-prog-name=ld`
659 case `"$ac_prog" -V 2>&1 < /dev/null` in
665 AC_MSG_RESULT($GNULD)
667 AC_MSG_CHECKING(for --enable-shared)
668 AC_ARG_ENABLE(shared,
669 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
671 if test -z "$enable_shared"
673 case $ac_sys_system in
675 enable_shared="yes";;
680 AC_MSG_RESULT($enable_shared)
682 AC_MSG_CHECKING(for --enable-profiling)
683 AC_ARG_ENABLE(profiling,
684 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
687 AC_TRY_RUN([int main() { return 0; }],
688 ac_enable_profiling="yes",
689 ac_enable_profiling="no",
690 ac_enable_profiling="no")
692 AC_MSG_RESULT($ac_enable_profiling)
694 case "$ac_enable_profiling" in
696 BASECFLAGS="-pg $BASECFLAGS"
697 LDFLAGS="-pg $LDFLAGS"
701 AC_MSG_CHECKING(LDLIBRARY)
703 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
704 # library that we build, but we do not want to link against it (we
705 # will find it with a -framework option). For this reason there is an
706 # extra variable BLDLIBRARY against which Python and the extension
707 # modules are linked, BLDLIBRARY. This is normally the same as
708 # LDLIBRARY, but empty for MacOSX framework builds.
709 if test "$enable_framework"
711 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
712 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
715 BLDLIBRARY='$(LDLIBRARY)'
718 # Other platforms follow
719 if test $enable_shared = "yes"; then
720 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
721 case $ac_sys_system in
723 LDLIBRARY='libpython$(VERSION).so'
726 LDLIBRARY='libpython$(VERSION).dll.a'
727 DLLLIBRARY='libpython$(VERSION).dll'
730 LDLIBRARY='libpython$(VERSION).so'
731 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
732 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
733 INSTSONAME="$LDLIBRARY".$SOVERSION
735 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
736 LDLIBRARY='libpython$(VERSION).so'
737 BLDLIBRARY='-L. -lpython$(VERSION)'
738 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
739 case $ac_sys_system in
741 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
744 INSTSONAME="$LDLIBRARY".$SOVERSION
749 LDLIBRARY='libpython$(VERSION).so'
752 LDLIBRARY='libpython$(VERSION).sl'
755 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
756 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
759 LDLIBRARY='libpython$(VERSION).so'
760 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
761 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
764 LDLIBRARY='libpython$(VERSION).so'
765 BLDLIBRARY='-L. -lpython$(VERSION)'
766 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
769 LDLIBRARY='libpython$(VERSION).dylib'
770 BLDLIBRARY='-L. -lpython$(VERSION)'
771 RUNSHARED='DYLD_LIBRARY_PATH=`pwd`:${DYLD_LIBRARY_PATH}'
775 else # shared is disabled
776 case $ac_sys_system in
778 BLDLIBRARY='$(LIBRARY)'
779 LDLIBRARY='libpython$(VERSION).dll.a'
784 AC_MSG_RESULT($LDLIBRARY)
788 AC_CHECK_PROGS(AR, ar aal, ar)
790 # tweak ARFLAGS only if the user didn't set it on the command line
792 if test -z "$ARFLAGS"
798 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
799 if test $SVNVERSION = found
801 SVNVERSION="svnversion \$(srcdir)"
803 SVNVERSION="echo Unversioned directory"
808 # install -d does not work on BSDI or HP-UX
809 if test -z "$INSTALL"
811 INSTALL="${srcdir}/install-sh -c"
816 # Not every filesystem supports hard links
818 if test -z "$LN" ; then
819 case $ac_sys_system in
821 CYGWIN*) LN="ln -s";;
822 atheos*) LN="ln -s";;
827 # Check for --with-pydebug
828 AC_MSG_CHECKING(for --with-pydebug)
830 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
832 if test "$withval" != no
834 AC_DEFINE(Py_DEBUG, 1,
835 [Define if you want to build an interpreter with many run-time checks.])
838 else AC_MSG_RESULT(no); Py_DEBUG='false'
842 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
843 # merged with this chunk of code?
845 # Optimizer/debugger flags
846 # ------------------------
847 # (The following bit of code is complicated enough - please keep things
848 # indented properly. Just pretend you're editing Python code. ;-)
850 # There are two parallel sets of case statements below, one that checks to
851 # see if OPT was set and one that does BASECFLAGS setting based upon
852 # compiler and platform. BASECFLAGS tweaks need to be made even if the
855 # tweak OPT based on compiler and platform, only if the user didn't set
856 # it on the command line
862 if test "$CC" != 'g++' ; then
863 STRICT_PROTO="-Wstrict-prototypes"
865 # For gcc 4.x we need to use -fwrapv so lets check if its supported
866 if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
869 case $ac_cv_prog_cc_g in
871 if test "$Py_DEBUG" = 'true' ; then
872 # Optimization messes up debuggers, so turn it off for
874 OPT="-g -Wall $STRICT_PROTO"
876 OPT="-g $WRAP -O3 -Wall $STRICT_PROTO"
880 OPT="-O3 -Wall $STRICT_PROTO"
883 case $ac_sys_system in
884 SCO_SV*) OPT="$OPT -m486 -DSCO5"
897 # The -arch flags for universal builds on OSX
898 UNIVERSAL_ARCH_FLAGS=
899 AC_SUBST(UNIVERSAL_ARCH_FLAGS)
901 # tweak BASECFLAGS based on compiler and platform
904 # Python violates C99 rules, by casting between incompatible
905 # pointer types. GCC may generate bad code as a result of that,
906 # so use -fno-strict-aliasing if supported.
907 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
909 CC="$CC -fno-strict-aliasing"
910 AC_CACHE_VAL(ac_cv_no_strict_aliasing_ok,
911 AC_TRY_RUN([int main() { return 0; }],
912 ac_cv_no_strict_aliasing_ok=yes,
913 ac_cv_no_strict_aliasing_ok=no,
914 ac_cv_no_strict_aliasing_ok=no))
916 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
917 if test $ac_cv_no_strict_aliasing_ok = yes
919 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
922 # if using gcc on alpha, use -mieee to get (near) full IEEE 754
923 # support. Without this, treatment of subnormals doesn't follow
925 case $ac_sys_machine in
927 BASECFLAGS="$BASECFLAGS -mieee"
931 case $ac_sys_system in
933 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
935 # is there any other compiler on Darwin besides gcc?
937 # -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
938 # used to be here, but non-Apple gcc doesn't accept them.
941 if test "${enable_universalsdk}"; then
942 UNIVERSAL_ARCH_FLAGS=""
943 if test "$UNIVERSAL_ARCHS" = "32-bit" ; then
944 UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386"
947 elif test "$UNIVERSAL_ARCHS" = "64-bit" ; then
948 UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64"
949 ARCH_RUN_32BIT="true"
951 elif test "$UNIVERSAL_ARCHS" = "all" ; then
952 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64"
953 ARCH_RUN_32BIT="arch -i386 -ppc"
955 elif test "$UNIVERSAL_ARCHS" = "intel" ; then
956 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch x86_64"
957 ARCH_RUN_32BIT="arch -i386"
959 elif test "$UNIVERSAL_ARCHS" = "3-way" ; then
960 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch x86_64"
961 ARCH_RUN_32BIT="arch -i386 -ppc"
964 AC_MSG_ERROR([proper usage is --with-universalarch=32-bit|64-bit|all])
969 BASECFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
970 tgt=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
971 if test "${UNIVERSALSDK}" != "/" -a "${tgt}" '>' '10.4' ; then
972 CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
976 # Calculate the right deployment target for this build.
978 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
979 if test ${cur_target} '>' 10.2; then
981 if test ${enable_universalsdk}; then
982 if test "${UNIVERSAL_ARCHS}" = "all"; then
983 # Ensure that the default platform for a
984 # 4-way universal build is OSX 10.5,
985 # that's the first OS release where
986 # 4-way builds make sense.
989 elif test "${UNIVERSAL_ARCHS}" = "3-way"; then
992 elif test "${UNIVERSAL_ARCHS}" = "intel"; then
995 elif test "${UNIVERSAL_ARCHS}" = "64-bit"; then
999 if test `arch` = "i386"; then
1000 # On Intel macs default to a deployment
1001 # target of 10.4, that's the first OSX
1002 # release with Intel support.
1007 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1009 # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
1010 # environment with a value that is the same as what we'll use
1011 # in the Makefile to ensure that we'll get the same compiler
1012 # environment during configure and build time.
1013 MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
1014 export MACOSX_DEPLOYMENT_TARGET
1015 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
1019 BASECFLAGS="$BASECFLAGS -mieee"
1025 case $ac_sys_system in
1026 OpenUNIX*|UnixWare*)
1027 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
1030 BASECFLAGS="$BASECFLAGS -ieee -std"
1033 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
1039 if test "$Py_DEBUG" = 'true'; then
1045 if test "$ac_arch_flags"
1047 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
1050 # disable check for icc since it seems to pass, but generates a warning
1053 ac_cv_opt_olimit_ok=no
1056 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
1057 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
1059 CC="$CC -OPT:Olimit=0"
1060 AC_TRY_RUN([int main() { return 0; }],
1061 ac_cv_opt_olimit_ok=yes,
1062 ac_cv_opt_olimit_ok=no,
1063 ac_cv_opt_olimit_ok=no)
1065 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
1066 if test $ac_cv_opt_olimit_ok = yes; then
1067 case $ac_sys_system in
1068 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
1069 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
1074 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
1078 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
1079 AC_CACHE_VAL(ac_cv_olimit_ok,
1081 CC="$CC -Olimit 1500"
1082 AC_TRY_RUN([int main() { return 0; }],
1083 ac_cv_olimit_ok=yes,
1087 AC_MSG_RESULT($ac_cv_olimit_ok)
1088 if test $ac_cv_olimit_ok = yes; then
1089 BASECFLAGS="$BASECFLAGS -Olimit 1500"
1093 # Check whether GCC supports PyArg_ParseTuple format
1094 if test "$GCC" = "yes"
1096 AC_MSG_CHECKING(whether gcc supports ParseTuple __format__)
1098 CFLAGS="$CFLAGS -Werror"
1100 void f(char*,...)__attribute((format(PyArg_ParseTuple, 1, 2)));
1102 AC_DEFINE(HAVE_ATTRIBUTE_FORMAT_PARSETUPLE, 1, [Define if GCC supports __attribute__((format(PyArg_ParseTuple, 2, 3)))])
1109 # On some compilers, pthreads are available without further options
1110 # (e.g. MacOS X). On some of these systems, the compiler will not
1111 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
1112 # So we have to see first whether pthreads are available without
1113 # options before we can check whether -Kpthread improves anything.
1114 AC_MSG_CHECKING(whether pthreads are available without options)
1115 AC_CACHE_VAL(ac_cv_pthread_is_default,
1117 #include <pthread.h>
1119 void* routine(void* p){return NULL;}
1123 if(pthread_create(&p,NULL,routine,NULL)!=0)
1125 (void)pthread_detach(p);
1130 ac_cv_pthread_is_default=yes
1134 ac_cv_pthread_is_default=no,
1135 ac_cv_pthread_is_default=no)
1137 AC_MSG_RESULT($ac_cv_pthread_is_default)
1140 if test $ac_cv_pthread_is_default = yes
1144 # -Kpthread, if available, provides the right #defines
1145 # and linker options to make pthread_create available
1146 # Some compilers won't report that they do not support -Kpthread,
1147 # so we need to run a program to see whether it really made the
1148 # function available.
1149 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
1150 AC_CACHE_VAL(ac_cv_kpthread,
1154 #include <pthread.h>
1156 void* routine(void* p){return NULL;}
1160 if(pthread_create(&p,NULL,routine,NULL)!=0)
1162 (void)pthread_detach(p);
1170 AC_MSG_RESULT($ac_cv_kpthread)
1173 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
1175 # -Kthread, if available, provides the right #defines
1176 # and linker options to make pthread_create available
1177 # Some compilers won't report that they do not support -Kthread,
1178 # so we need to run a program to see whether it really made the
1179 # function available.
1180 AC_MSG_CHECKING(whether $CC accepts -Kthread)
1181 AC_CACHE_VAL(ac_cv_kthread,
1185 #include <pthread.h>
1187 void* routine(void* p){return NULL;}
1191 if(pthread_create(&p,NULL,routine,NULL)!=0)
1193 (void)pthread_detach(p);
1201 AC_MSG_RESULT($ac_cv_kthread)
1204 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
1206 # -pthread, if available, provides the right #defines
1207 # and linker options to make pthread_create available
1208 # Some compilers won't report that they do not support -pthread,
1209 # so we need to run a program to see whether it really made the
1210 # function available.
1211 AC_MSG_CHECKING(whether $CC accepts -pthread)
1212 AC_CACHE_VAL(ac_cv_thread,
1216 #include <pthread.h>
1218 void* routine(void* p){return NULL;}
1222 if(pthread_create(&p,NULL,routine,NULL)!=0)
1224 (void)pthread_detach(p);
1232 AC_MSG_RESULT($ac_cv_pthread)
1235 # If we have set a CC compiler flag for thread support then
1236 # check if it works for CXX, too.
1240 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1243 if test "$ac_cv_kpthread" = "yes"
1245 CXX="$CXX -Kpthread"
1246 ac_cv_cxx_thread=yes
1247 elif test "$ac_cv_kthread" = "yes"
1250 ac_cv_cxx_thread=yes
1251 elif test "$ac_cv_pthread" = "yes"
1254 ac_cv_cxx_thread=yes
1257 if test $ac_cv_cxx_thread = yes
1259 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1260 $CXX -c conftest.$ac_ext 2>&5
1261 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1262 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1264 ac_cv_cxx_thread=yes
1270 AC_MSG_RESULT($ac_cv_cxx_thread)
1274 dnl # check for ANSI or K&R ("traditional") preprocessor
1275 dnl AC_MSG_CHECKING(for C preprocessor type)
1276 dnl AC_TRY_COMPILE([
1277 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1279 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1280 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1281 dnl AC_MSG_RESULT($cpp_type)
1283 # checks for header files
1285 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1287 ieeefp.h io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
1288 shadow.h signal.h stdint.h stropts.h termios.h thread.h \
1290 sys/audioio.h sys/bsdtty.h sys/epoll.h sys/event.h sys/file.h sys/loadavg.h \
1291 sys/lock.h sys/mkdev.h sys/modem.h \
1292 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1293 sys/termio.h sys/time.h \
1294 sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1295 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1296 bluetooth/bluetooth.h linux/tipc.h)
1300 # On Solaris, term.h requires curses.h
1301 AC_CHECK_HEADERS(term.h,,,[
1302 #ifdef HAVE_CURSES_H
1307 # On Linux, netlink.h requires asm/types.h
1308 AC_CHECK_HEADERS(linux/netlink.h,,,[
1309 #ifdef HAVE_ASM_TYPES_H
1310 #include <asm/types.h>
1312 #ifdef HAVE_SYS_SOCKET_H
1313 #include <sys/socket.h>
1317 # checks for typedefs
1319 AC_MSG_CHECKING(for clock_t in time.h)
1320 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1321 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1323 AC_MSG_RESULT($was_it_defined)
1325 # Check whether using makedev requires defining _OSF_SOURCE
1326 AC_MSG_CHECKING(for makedev)
1327 AC_TRY_LINK([#include <sys/types.h> ],
1329 ac_cv_has_makedev=yes,
1330 ac_cv_has_makedev=no)
1331 if test "$ac_cv_has_makedev" = "no"; then
1332 # we didn't link, try if _OSF_SOURCE will allow us to link
1334 #define _OSF_SOURCE 1
1335 #include <sys/types.h>
1338 ac_cv_has_makedev=yes,
1339 ac_cv_has_makedev=no)
1340 if test "$ac_cv_has_makedev" = "yes"; then
1341 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1344 AC_MSG_RESULT($ac_cv_has_makedev)
1345 if test "$ac_cv_has_makedev" = "yes"; then
1346 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1349 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1350 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1351 # defined, but the compiler does not support pragma redefine_extname,
1352 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1353 # structures (such as rlimit64) without declaring them. As a
1354 # work-around, disable LFS on such configurations
1357 AC_MSG_CHECKING(Solaris LFS bug)
1359 #define _LARGEFILE_SOURCE 1
1360 #define _FILE_OFFSET_BITS 64
1361 #include <sys/resource.h>
1362 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1363 AC_MSG_RESULT($sol_lfs_bug)
1364 if test "$sol_lfs_bug" = "yes"; then
1368 if test "$use_lfs" = "yes"; then
1369 # Two defines needed to enable largefile support on various platforms
1370 # These may affect some typedefs
1371 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1372 [This must be defined on some systems to enable large file support.])
1373 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1374 [This must be set to 64 on some systems to enable large file support.])
1377 # Add some code to confdefs.h so that the test for off_t works on SCO
1378 cat >> confdefs.h <<\EOF
1384 # Type availability checks
1395 AC_CHECK_TYPE(ssize_t,
1396 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1398 # Sizes of various common basic types
1399 # ANSI C requires sizeof(char) == 1, so no need to check it
1400 AC_CHECK_SIZEOF(int, 4)
1401 AC_CHECK_SIZEOF(long, 4)
1402 AC_CHECK_SIZEOF(void *, 4)
1403 AC_CHECK_SIZEOF(short, 2)
1404 AC_CHECK_SIZEOF(float, 4)
1405 AC_CHECK_SIZEOF(double, 8)
1406 AC_CHECK_SIZEOF(fpos_t, 4)
1407 AC_CHECK_SIZEOF(size_t, 4)
1408 AC_CHECK_SIZEOF(pid_t, 4)
1410 AC_MSG_CHECKING(for long long support)
1412 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1413 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1416 AC_MSG_RESULT($have_long_long)
1417 if test "$have_long_long" = yes ; then
1418 AC_CHECK_SIZEOF(long long, 8)
1421 AC_MSG_CHECKING(for long double support)
1423 AC_TRY_COMPILE([], [long double x; x = (long double)0.;], [
1424 AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define this if you have the type long double.])
1425 have_long_double=yes
1427 AC_MSG_RESULT($have_long_double)
1428 if test "$have_long_double" = yes ; then
1429 AC_CHECK_SIZEOF(long double, 12)
1432 AC_MSG_CHECKING(for _Bool support)
1434 AC_TRY_COMPILE([], [_Bool x; x = (_Bool)0;], [
1435 AC_DEFINE(HAVE_C99_BOOL, 1, [Define this if you have the type _Bool.])
1438 AC_MSG_RESULT($have_c99_bool)
1439 if test "$have_c99_bool" = yes ; then
1440 AC_CHECK_SIZEOF(_Bool, 1)
1443 AC_CHECK_TYPES(uintptr_t,
1444 [AC_CHECK_SIZEOF(uintptr_t, 4)],
1445 [], [#ifdef HAVE_STDINT_H
1449 AC_CHECK_SIZEOF(off_t, [], [
1450 #ifdef HAVE_SYS_TYPES_H
1451 #include <sys/types.h>
1455 AC_MSG_CHECKING(whether to enable large file support)
1456 if test "$have_long_long" = yes -a \
1457 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1458 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1459 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1460 [Defined to enable large file support when an off_t is bigger than a long
1461 and long long is available and at least as big as an off_t. You may need
1462 to add some flags for configuration and compilation to enable this mode.
1463 (For Solaris and Linux, the necessary defines are already defined.)])
1469 AC_CHECK_SIZEOF(time_t, [], [
1470 #ifdef HAVE_SYS_TYPES_H
1471 #include <sys/types.h>
1478 # if have pthread_t then define SIZEOF_PTHREAD_T
1480 if test "$ac_cv_kpthread" = "yes"
1481 then CC="$CC -Kpthread"
1482 elif test "$ac_cv_kthread" = "yes"
1483 then CC="$CC -Kthread"
1484 elif test "$ac_cv_pthread" = "yes"
1485 then CC="$CC -pthread"
1487 AC_MSG_CHECKING(for pthread_t)
1489 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1490 AC_MSG_RESULT($have_pthread_t)
1491 if test "$have_pthread_t" = yes ; then
1492 AC_CHECK_SIZEOF(pthread_t, [], [
1493 #ifdef HAVE_PTHREAD_H
1494 #include <pthread.h>
1500 AC_MSG_CHECKING(for --enable-toolbox-glue)
1501 AC_ARG_ENABLE(toolbox-glue,
1502 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1504 if test -z "$enable_toolbox_glue"
1506 case $ac_sys_system/$ac_sys_release in
1508 enable_toolbox_glue="yes";;
1510 enable_toolbox_glue="no";;
1513 case "$enable_toolbox_glue" in
1515 extra_machdep_objs="Python/mactoolboxglue.o"
1516 extra_undefs="-u _PyMac_Error"
1517 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1518 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1521 extra_machdep_objs=""
1525 AC_MSG_RESULT($enable_toolbox_glue)
1528 AC_SUBST(OTHER_LIBTOOL_OPT)
1529 case $ac_sys_system/$ac_sys_release in
1530 Darwin/@<:@01567@:>@\..*)
1531 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1534 OTHER_LIBTOOL_OPT=""
1540 AC_SUBST(LIBTOOL_CRUFT)
1541 case $ac_sys_system/$ac_sys_release in
1542 Darwin/@<:@01567@:>@\..*)
1543 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1544 if test "${enable_universalsdk}"; then
1547 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1549 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1550 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1552 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1553 if test ${gcc_version} '<' 4.0
1555 LIBTOOL_CRUFT="-lcc_dynamic"
1561 int main(int argc, char*argv[])
1563 if (sizeof(long) == 4) {
1569 ], ac_osx_32bit=yes,
1573 if test "${ac_osx_32bit}" = "yes"; then
1576 MACOSX_DEFAULT_ARCH="i386"
1579 MACOSX_DEFAULT_ARCH="ppc"
1582 AC_MSG_ERROR([Unexpected output of 'arch' on OSX])
1588 MACOSX_DEFAULT_ARCH="x86_64"
1591 MACOSX_DEFAULT_ARCH="ppc64"
1594 AC_MSG_ERROR([Unexpected output of 'arch' on OSX])
1598 #ARCH_RUN_32BIT="true"
1601 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only ${MACOSX_DEFAULT_ARCH}"
1602 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1603 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1606 AC_MSG_CHECKING(for --enable-framework)
1607 if test "$enable_framework"
1609 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1610 # -F. is needed to allow linking to the framework while
1611 # in the build location.
1612 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1613 [Define if you want to produce an OpenStep/Rhapsody framework
1614 (shared library plus accessory files).])
1616 if test $enable_shared = "yes"
1618 AC_MSG_ERROR([Specifying both --enable-shared and --enable-framework is not supported, use only --enable-framework instead])
1624 AC_MSG_CHECKING(for dyld)
1625 case $ac_sys_system/$ac_sys_release in
1627 AC_DEFINE(WITH_DYLD, 1,
1628 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1629 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1630 linker (rld). Dyld is necessary to support frameworks.])
1631 AC_MSG_RESULT(always on for Darwin)
1638 # Set info about shared libraries.
1643 AC_SUBST(LINKFORSHARED)
1644 # SO is the extension of shared libraries `(including the dot!)
1645 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1649 case $ac_sys_system in
1660 # this might also be a termcap variable, see #610332
1662 echo '====================================================================='
1664 echo '+ WARNING: You have set SO in your environment. +'
1665 echo '+ Do you really mean to change the extension for shared libraries? +'
1666 echo '+ Continuing in 10 seconds to let you to ponder. +'
1668 echo '====================================================================='
1673 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1674 # LDSHARED is the ld *command* used to create shared library
1675 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1676 # (Shared libraries in this instance are shared modules to be loaded into
1677 # Python, as opposed to building Python itself as a shared library.)
1678 AC_MSG_CHECKING(LDSHARED)
1679 if test -z "$LDSHARED"
1681 case $ac_sys_system/$ac_sys_release in
1683 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1684 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1687 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1688 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1690 IRIX/5*) LDSHARED="ld -shared";;
1691 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1693 if test "$GCC" = "yes"
1694 then LDSHARED='$(CC) -shared'
1695 else LDSHARED='$(CC) -G';
1698 if test "$GCC" = "yes"
1699 then LDSHARED='$(CC) -shared'
1700 else LDSHARED='ld -b';
1702 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1704 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1705 if test "$enable_framework" ; then
1706 # Link against the framework. All externals should be defined.
1707 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1708 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1710 # No framework. Ignore undefined symbols, assuming they come from Python
1711 LDSHARED="$LDSHARED -undefined suppress"
1713 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1714 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1715 if test "$enable_framework" ; then
1716 # Link against the framework. All externals should be defined.
1717 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1718 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1720 # No framework, use the Python app as bundle-loader
1721 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1722 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1725 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1726 # This allows an extension to be used in any Python
1728 if test ${MACOSX_DEPLOYMENT_TARGET} '>' 10.2
1730 if test "${enable_universalsdk}"; then
1731 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1733 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1734 BLDSHARED="$LDSHARED"
1736 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1737 if test "$enable_framework" ; then
1738 # Link against the framework. All externals should be defined.
1739 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1740 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1742 # No framework, use the Python app as bundle-loader
1743 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1744 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1748 Linux*|GNU*|QNX*) LDSHARED='$(CC) -shared';;
1749 BSD/OS*/4*) LDSHARED="gcc -shared";;
1751 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1753 LDSHARED="$CC -shared ${LDFLAGS}"
1755 LDSHARED="ld -Bshareable ${LDFLAGS}"
1758 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1760 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1763 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1764 LDSHARED="ld -Bshareable ${LDFLAGS}"
1767 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1771 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1772 OpenUNIX*|UnixWare*)
1773 if test "$GCC" = "yes"
1774 then LDSHARED='$(CC) -shared'
1775 else LDSHARED='$(CC) -G'
1777 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1778 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1779 atheos*) LDSHARED="gcc -shared";;
1783 AC_MSG_RESULT($LDSHARED)
1784 BLDSHARED=${BLDSHARED-$LDSHARED}
1785 # CCSHARED are the C *flags* used to create objects to go into a shared
1786 # library (module) -- this is only needed for a few systems
1787 AC_MSG_CHECKING(CCSHARED)
1788 if test -z "$CCSHARED"
1790 case $ac_sys_system/$ac_sys_release in
1791 SunOS*) if test "$GCC" = yes;
1792 then CCSHARED="-fPIC";
1793 elif test `uname -p` = sparc;
1794 then CCSHARED="-xcode=pic32";
1795 else CCSHARED="-Kpic";
1797 hp*|HP*) if test "$GCC" = yes;
1798 then CCSHARED="-fPIC";
1801 Linux*|GNU*) CCSHARED="-fPIC";;
1802 BSD/OS*/4*) CCSHARED="-fpic";;
1803 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1804 OpenUNIX*|UnixWare*)
1805 if test "$GCC" = "yes"
1806 then CCSHARED="-fPIC"
1807 else CCSHARED="-KPIC"
1810 if test "$GCC" = "yes"
1811 then CCSHARED="-fPIC"
1812 else CCSHARED="-Kpic -belf"
1814 IRIX*/6*) case $CC in
1815 *gcc*) CCSHARED="-shared";;
1818 atheos*) CCSHARED="-fPIC";;
1821 AC_MSG_RESULT($CCSHARED)
1822 # LINKFORSHARED are the flags passed to the $(CC) command that links
1823 # the python executable -- this is only needed for a few systems
1824 AC_MSG_CHECKING(LINKFORSHARED)
1825 if test -z "$LINKFORSHARED"
1827 case $ac_sys_system/$ac_sys_release in
1828 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1830 LINKFORSHARED="-Wl,-E -Wl,+s";;
1831 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1832 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1833 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1834 # -u libsys_s pulls in all symbols in libsys
1836 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1838 # not used by the core itself but which needs to be in the core so
1839 # that dynamically loaded extension modules have access to it.
1840 # -prebind is no longer used, because it actually seems to give a
1841 # slowdown in stead of a speedup, maybe due to the large number of
1842 # dynamic loads Python does.
1844 LINKFORSHARED="$extra_undefs"
1845 if test "$enable_framework"
1847 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1849 LINKFORSHARED="$LINKFORSHARED";;
1850 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1851 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1852 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1853 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1854 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1856 LINKFORSHARED="-Wl,--export-dynamic"
1858 SunOS/5*) case $CC in
1860 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1862 LINKFORSHARED="-Xlinker --export-dynamic"
1866 if test $enable_shared = "no"
1868 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1871 # -Wl,-E causes the symbols to be added to the dynamic
1872 # symbol table so that they can be found when a module
1873 # is loaded. -N 2048K causes the stack size to be set
1874 # to 2048 kilobytes so that the stack doesn't overflow
1875 # when running test_compile.py.
1876 LINKFORSHARED='-Wl,-E -N 2048K';;
1879 AC_MSG_RESULT($LINKFORSHARED)
1882 AC_SUBST(CFLAGSFORSHARED)
1883 AC_MSG_CHECKING(CFLAGSFORSHARED)
1884 if test ! "$LIBRARY" = "$LDLIBRARY"
1886 case $ac_sys_system in
1888 # Cygwin needs CCSHARED when building extension DLLs
1889 # but not when building the interpreter DLL.
1890 CFLAGSFORSHARED='';;
1892 CFLAGSFORSHARED='$(CCSHARED)'
1895 AC_MSG_RESULT($CFLAGSFORSHARED)
1897 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1898 # library (with --enable-shared).
1899 # For platforms on which shared libraries are not allowed to have unresolved
1900 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1901 # if it is not required, since it creates a dependency of the shared library
1902 # to LIBS. This, in turn, means that applications linking the shared libpython
1903 # don't need to link LIBS explicitly. The default should be only changed
1904 # on systems where this approach causes problems.
1906 AC_MSG_CHECKING(SHLIBS)
1907 case "$ac_sys_system" in
1911 AC_MSG_RESULT($SHLIBS)
1914 # checks for libraries
1915 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1916 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1918 # only check for sem_init if thread support is requested
1919 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1920 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1921 # posix4 on Solaris 2.6
1922 # pthread (first!) on Linux
1925 # check if we need libintl for locale functions
1926 AC_CHECK_LIB(intl, textdomain,
1927 AC_DEFINE(WITH_LIBINTL, 1,
1928 [Define to 1 if libintl is needed for locale functions.]))
1930 # checks for system dependent C++ extensions support
1931 case "$ac_sys_system" in
1932 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1933 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1934 [loadAndInit("", 0, "")],
1935 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1936 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1937 and you want support for AIX C++ shared extension modules.])
1938 AC_MSG_RESULT(yes)],
1939 [AC_MSG_RESULT(no)]);;
1943 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1944 # BeOS' sockets are stashed in libnet.
1945 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1946 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1948 case "$ac_sys_system" in
1950 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1954 AC_MSG_CHECKING(for --with-libs)
1956 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1958 AC_MSG_RESULT($withval)
1959 LIBS="$withval $LIBS"
1961 [AC_MSG_RESULT(no)])
1963 # Check for use of the system libffi library
1964 AC_MSG_CHECKING(for --with-system-ffi)
1965 AC_ARG_WITH(system_ffi,
1966 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1968 AC_MSG_RESULT($with_system_ffi)
1970 # Check for --with-dbmliborder
1971 AC_MSG_CHECKING(for --with-dbmliborder)
1972 AC_ARG_WITH(dbmliborder,
1973 AC_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'.]),
1975 if test x$with_dbmliborder = xyes
1977 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
1979 for db in `echo $with_dbmliborder | sed 's/:/ /g'`; do
1980 if test x$db != xndbm && test x$db != xgdbm && test x$db != xbdb
1982 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
1986 AC_MSG_RESULT($with_dbmliborder)
1988 # Determine if signalmodule should be used.
1989 AC_SUBST(USE_SIGNAL_MODULE)
1990 AC_SUBST(SIGNAL_OBJS)
1991 AC_MSG_CHECKING(for --with-signal-module)
1992 AC_ARG_WITH(signal-module,
1993 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1995 if test -z "$with_signal_module"
1996 then with_signal_module="yes"
1998 AC_MSG_RESULT($with_signal_module)
2000 if test "${with_signal_module}" = "yes"; then
2001 USE_SIGNAL_MODULE=""
2004 USE_SIGNAL_MODULE="#"
2005 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
2008 # This is used to generate Setup.config
2009 AC_SUBST(USE_THREAD_MODULE)
2010 USE_THREAD_MODULE=""
2012 AC_MSG_CHECKING(for --with-dec-threads)
2014 AC_ARG_WITH(dec-threads,
2015 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
2017 AC_MSG_RESULT($withval)
2019 if test "${with_thread+set}" != set; then
2020 with_thread="$withval";
2022 [AC_MSG_RESULT(no)])
2024 # Templates for things AC_DEFINEd more than once.
2025 # For a single AC_DEFINE, no template is needed.
2026 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
2027 AH_TEMPLATE(_REENTRANT,
2028 [Define to force use of thread-safe errno, h_errno, and other functions])
2029 AH_TEMPLATE(WITH_THREAD,
2030 [Define if you want to compile in rudimentary thread support])
2032 AC_MSG_CHECKING(for --with-threads)
2033 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2034 AC_ARG_WITH(threads,
2035 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
2037 # --with-thread is deprecated, but check for it anyway
2038 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2040 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
2041 [with_threads=$with_thread])
2043 if test -z "$with_threads"
2044 then with_threads="yes"
2046 AC_MSG_RESULT($with_threads)
2049 if test "$with_threads" = "no"
2051 USE_THREAD_MODULE="#"
2052 elif test "$ac_cv_pthread_is_default" = yes
2054 AC_DEFINE(WITH_THREAD)
2055 # Defining _REENTRANT on system with POSIX threads should not hurt.
2056 AC_DEFINE(_REENTRANT)
2058 THREADOBJ="Python/thread.o"
2059 elif test "$ac_cv_kpthread" = "yes"
2062 if test "$ac_cv_cxx_thread" = "yes"; then
2063 CXX="$CXX -Kpthread"
2065 AC_DEFINE(WITH_THREAD)
2067 THREADOBJ="Python/thread.o"
2068 elif test "$ac_cv_kthread" = "yes"
2071 if test "$ac_cv_cxx_thread" = "yes"; then
2074 AC_DEFINE(WITH_THREAD)
2076 THREADOBJ="Python/thread.o"
2077 elif test "$ac_cv_pthread" = "yes"
2080 if test "$ac_cv_cxx_thread" = "yes"; then
2083 AC_DEFINE(WITH_THREAD)
2085 THREADOBJ="Python/thread.o"
2087 if test ! -z "$with_threads" -a -d "$with_threads"
2088 then LDFLAGS="$LDFLAGS -L$with_threads"
2090 if test ! -z "$withval" -a -d "$withval"
2091 then LDFLAGS="$LDFLAGS -L$withval"
2094 # According to the POSIX spec, a pthreads implementation must
2095 # define _POSIX_THREADS in unistd.h. Some apparently don't
2096 # (e.g. gnu pth with pthread emulation)
2097 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
2101 #ifdef _POSIX_THREADS
2104 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
2105 AC_MSG_RESULT($unistd_defines_pthreads)
2107 AC_DEFINE(_REENTRANT)
2108 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
2109 AC_DEFINE(C_THREADS)
2110 AC_DEFINE(HURD_C_THREADS, 1,
2111 [Define if you are using Mach cthreads directly under /include])
2112 LIBS="$LIBS -lthreads"
2113 THREADOBJ="Python/thread.o"],[
2114 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
2115 AC_DEFINE(C_THREADS)
2116 AC_DEFINE(MACH_C_THREADS, 1,
2117 [Define if you are using Mach cthreads under mach /])
2118 THREADOBJ="Python/thread.o"],[
2119 AC_MSG_CHECKING(for --with-pth)
2121 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
2122 [AC_MSG_RESULT($withval)
2123 AC_DEFINE([WITH_THREAD])
2124 AC_DEFINE([HAVE_PTH], 1,
2125 [Define if you have GNU PTH threads.])
2127 THREADOBJ="Python/thread.o"],
2130 # Just looking for pthread_create in libpthread is not enough:
2131 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
2132 # So we really have to include pthread.h, and then link.
2134 LIBS="$LIBS -lpthread"
2135 AC_MSG_CHECKING([for pthread_create in -lpthread])
2136 AC_TRY_LINK([#include <pthread.h>
2138 void * start_routine (void *arg) { exit (0); }], [
2139 pthread_create (NULL, NULL, start_routine, NULL)], [
2141 AC_DEFINE(WITH_THREAD)
2143 THREADOBJ="Python/thread.o"],[
2145 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
2147 THREADOBJ="Python/thread.o"],[
2148 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
2149 AC_DEFINE(ATHEOS_THREADS, 1,
2150 [Define this if you have AtheOS threads.])
2151 THREADOBJ="Python/thread.o"],[
2152 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
2153 AC_DEFINE(BEOS_THREADS, 1,
2154 [Define this if you have BeOS threads.])
2155 THREADOBJ="Python/thread.o"],[
2156 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
2158 LIBS="$LIBS -lpthreads"
2159 THREADOBJ="Python/thread.o"], [
2160 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
2163 THREADOBJ="Python/thread.o"], [
2164 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
2166 LIBS="$LIBS -lpthread"
2167 THREADOBJ="Python/thread.o"], [
2168 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
2171 THREADOBJ="Python/thread.o"],[
2172 USE_THREAD_MODULE="#"])
2173 ])])])])])])])])])])
2175 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
2177 THREADOBJ="Python/thread.o"
2178 USE_THREAD_MODULE=""])
2180 if test "$posix_threads" != "yes"; then
2181 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
2182 LIBS="$LIBS -lthread"
2183 THREADOBJ="Python/thread.o"
2184 USE_THREAD_MODULE=""])
2187 if test "$USE_THREAD_MODULE" != "#"
2189 # If the above checks didn't disable threads, (at least) OSF1
2190 # needs this '-threads' argument during linking.
2191 case $ac_sys_system in
2192 OSF1) LDLAST=-threads;;
2197 if test "$posix_threads" = "yes"; then
2198 if test "$unistd_defines_pthreads" = "no"; then
2199 AC_DEFINE(_POSIX_THREADS, 1,
2200 [Define if you have POSIX threads,
2201 and your system does not define that.])
2204 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
2205 case $ac_sys_system/$ac_sys_release in
2206 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
2207 Defined for Solaris 2.6 bug in pthread header.)
2209 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2210 Define if the Posix semaphores do not work on your system)
2212 AIX/5) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2213 Define if the Posix semaphores do not work on your system)
2217 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
2218 AC_CACHE_VAL(ac_cv_pthread_system_supported,
2219 [AC_TRY_RUN([#include <pthread.h>
2220 void *foo(void *parm) {
2224 pthread_attr_t attr;
2226 if (pthread_attr_init(&attr)) exit(-1);
2227 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
2228 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
2231 ac_cv_pthread_system_supported=yes,
2232 ac_cv_pthread_system_supported=no,
2233 ac_cv_pthread_system_supported=no)
2235 AC_MSG_RESULT($ac_cv_pthread_system_supported)
2236 if test "$ac_cv_pthread_system_supported" = "yes"; then
2237 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2239 AC_CHECK_FUNCS(pthread_sigmask,
2240 [case $ac_sys_system in
2242 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2243 [Define if pthread_sigmask() does not work on your system.])
2249 # Check for enable-ipv6
2250 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2251 AC_MSG_CHECKING([if --enable-ipv6 is specified])
2253 [ --enable-ipv6 Enable ipv6 (with ipv4) support
2254 --disable-ipv6 Disable ipv6 support],
2255 [ case "$enableval" in
2260 *) AC_MSG_RESULT(yes)
2261 AC_DEFINE(ENABLE_IPV6)
2267 dnl the check does not work on cross compilation case...
2268 AC_TRY_RUN([ /* AF_INET6 available check */
2269 #include <sys/types.h>
2270 #include <sys/socket.h>
2273 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2287 if test "$ipv6" = "yes"; then
2288 AC_MSG_CHECKING(if RFC2553 API is available)
2289 AC_TRY_COMPILE([#include <sys/types.h>
2290 #include <netinet/in.h>],
2291 [struct sockaddr_in6 x;
2295 AC_MSG_RESULT(no, IPv6 disabled)
2299 if test "$ipv6" = "yes"; then
2300 AC_DEFINE(ENABLE_IPV6)
2308 if test "$ipv6" = "yes"; then
2309 AC_MSG_CHECKING([ipv6 stack type])
2310 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2314 dnl http://www.kame.net/
2316 #include <netinet/in.h>
2317 #ifdef IPV6_INRIA_VERSION
2323 dnl http://www.kame.net/
2325 #include <netinet/in.h>
2331 ipv6libdir=/usr/local/v6/lib
2335 dnl http://www.v6.linux.or.jp/
2337 #include <features.h>
2338 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2345 dnl http://www.v6.linux.or.jp/
2346 if test -d /usr/inet6; then
2349 ipv6libdir=/usr/inet6/lib
2350 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2354 if test -f /etc/netconfig; then
2355 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2363 #include <sys/param.h>
2364 #ifdef _TOSHIBA_INET6
2369 ipv6libdir=/usr/local/v6/lib])
2373 #include </usr/local/v6/include/sys/v6config.h>
2379 ipv6libdir=/usr/local/v6/lib;
2380 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2384 #include <sys/param.h>
2385 #ifdef _ZETA_MINAMI_INET6
2390 ipv6libdir=/usr/local/v6/lib])
2393 if test "$ipv6type" != "unknown"; then
2397 AC_MSG_RESULT($ipv6type)
2400 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2401 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2402 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2403 echo "using lib$ipv6lib"
2405 if test $ipv6trylibc = "yes"; then
2408 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2409 echo "You need to fetch lib$ipv6lib.a from appropriate"
2410 echo 'ipv6 kit and compile beforehand.'
2416 AC_MSG_CHECKING(for OSX 10.5 SDK or later)
2417 AC_TRY_COMPILE([#include <Carbon/Carbon.h>], FSIORefNum fRef = 0,
2418 AC_DEFINE(HAVE_OSX105_SDK, 1, Define if compiling using MacOS X 10.5 SDK or later.)
2423 # Check for --with-doc-strings
2424 AC_MSG_CHECKING(for --with-doc-strings)
2425 AC_ARG_WITH(doc-strings,
2426 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2428 if test -z "$with_doc_strings"
2429 then with_doc_strings="yes"
2431 if test "$with_doc_strings" != "no"
2433 AC_DEFINE(WITH_DOC_STRINGS, 1,
2434 [Define if you want documentation strings in extension modules])
2436 AC_MSG_RESULT($with_doc_strings)
2438 # Check for Python-specific malloc support
2439 AC_MSG_CHECKING(for --with-tsc)
2441 [ --with(out)-tsc enable/disable timestamp counter profile], [
2442 if test "$withval" != no
2444 AC_DEFINE(WITH_TSC, 1,
2445 [Define to profile with the Pentium timestamp counter])
2447 else AC_MSG_RESULT(no)
2449 [AC_MSG_RESULT(no)])
2451 # Check for Python-specific malloc support
2452 AC_MSG_CHECKING(for --with-pymalloc)
2453 AC_ARG_WITH(pymalloc,
2454 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2456 if test -z "$with_pymalloc"
2457 then with_pymalloc="yes"
2459 if test "$with_pymalloc" != "no"
2461 AC_DEFINE(WITH_PYMALLOC, 1,
2462 [Define if you want to compile in Python-specific mallocs])
2464 AC_MSG_RESULT($with_pymalloc)
2466 # Check for --with-wctype-functions
2467 AC_MSG_CHECKING(for --with-wctype-functions)
2468 AC_ARG_WITH(wctype-functions,
2469 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2471 if test "$withval" != no
2473 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2474 [Define if you want wctype.h functions to be used instead of the
2475 one supplied by Python itself. (see Include/unicodectype.h).])
2477 else AC_MSG_RESULT(no)
2479 [AC_MSG_RESULT(no)])
2481 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2485 # the dlopen() function means we might want to use dynload_shlib.o. some
2486 # platforms, such as AIX, have dlopen(), but don't want to use it.
2487 AC_CHECK_FUNCS(dlopen)
2489 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2490 # loading of modules.
2491 AC_SUBST(DYNLOADFILE)
2492 AC_MSG_CHECKING(DYNLOADFILE)
2493 if test -z "$DYNLOADFILE"
2495 case $ac_sys_system/$ac_sys_release in
2496 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2497 if test "$ac_cv_func_dlopen" = yes
2498 then DYNLOADFILE="dynload_shlib.o"
2499 else DYNLOADFILE="dynload_aix.o"
2502 BeOS*) DYNLOADFILE="dynload_beos.o";;
2503 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2504 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2505 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2506 atheos*) DYNLOADFILE="dynload_atheos.o";;
2508 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2509 # out any dynamic loading
2510 if test "$ac_cv_func_dlopen" = yes
2511 then DYNLOADFILE="dynload_shlib.o"
2512 else DYNLOADFILE="dynload_stub.o"
2517 AC_MSG_RESULT($DYNLOADFILE)
2518 if test "$DYNLOADFILE" != "dynload_stub.o"
2520 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2521 [Defined when any dynamic module loading is enabled.])
2524 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2526 AC_SUBST(MACHDEP_OBJS)
2527 AC_MSG_CHECKING(MACHDEP_OBJS)
2528 if test -z "$MACHDEP_OBJS"
2530 MACHDEP_OBJS=$extra_machdep_objs
2532 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2534 AC_MSG_RESULT(MACHDEP_OBJS)
2536 # checks for library functions
2537 AC_CHECK_FUNCS(alarm setitimer getitimer bind_textdomain_codeset chown \
2538 clock confstr ctermid execv fchmod fchown fork fpathconf ftime ftruncate \
2539 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2540 getpriority getpwent getspnam getspent getsid getwd \
2541 kill killpg lchmod lchown lstat mkfifo mknod mktime \
2542 mremap nice pathconf pause plock poll pthread_init \
2543 putenv readlink realpath \
2544 select sem_open sem_timedwait sem_getvalue sem_unlink setegid seteuid \
2546 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2547 sigaction siginterrupt sigrelse strftime \
2548 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2549 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2551 # For some functions, having a definition is not sufficient, since
2552 # we want to take their address.
2553 AC_MSG_CHECKING(for chroot)
2554 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2555 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2559 AC_MSG_CHECKING(for link)
2560 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2561 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2565 AC_MSG_CHECKING(for symlink)
2566 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2567 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2571 AC_MSG_CHECKING(for fchdir)
2572 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2573 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2577 AC_MSG_CHECKING(for fsync)
2578 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2579 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2583 AC_MSG_CHECKING(for fdatasync)
2584 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2585 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2589 AC_MSG_CHECKING(for epoll)
2590 AC_TRY_COMPILE([#include <sys/epoll.h>], void *x=epoll_create,
2591 AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
2595 AC_MSG_CHECKING(for kqueue)
2597 #include <sys/types.h>
2598 #include <sys/event.h>
2600 AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
2604 # On some systems (eg. FreeBSD 5), we would find a definition of the
2605 # functions ctermid_r, setgroups in the library, but no prototype
2606 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2607 # address to avoid compiler warnings and potential miscompilations
2608 # because of the missing prototypes.
2610 AC_MSG_CHECKING(for ctermid_r)
2612 #include "confdefs.h"
2614 ], void* p = ctermid_r,
2615 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2620 AC_MSG_CHECKING(for flock)
2622 #include "confdefs.h"
2623 #include <sys/file.h>
2625 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2630 AC_MSG_CHECKING(for getpagesize)
2632 #include "confdefs.h"
2634 ], void* p = getpagesize,
2635 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2641 AC_CHECK_PROGS(TRUE, true, /bin/true)
2643 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2644 dnl On others, they are in the C library, so we to take no action
2645 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2646 AC_CHECK_LIB(resolv, inet_aton)
2649 # On Tru64, chflags seems to be present, but calling it will
2651 AC_MSG_CHECKING(for chflags)
2652 AC_CACHE_VAL(ac_cv_have_chflags,
2654 #include <sys/stat.h>
2656 int main(int argc, char*argv[])
2658 if(chflags(argv[0], 0) != 0)
2662 ]], ac_cv_have_chflags=yes,
2663 ac_cv_have_chflags=no,
2664 ac_cv_have_chflags=no)
2666 AC_MSG_RESULT($ac_cv_have_chflags)
2667 if test $ac_cv_have_chflags = yes
2669 AC_DEFINE(HAVE_CHFLAGS, 1, Define to 1 if you have the `chflags' function.)
2672 AC_MSG_CHECKING(for lchflags)
2673 AC_CACHE_VAL(ac_cv_have_lchflags,
2675 #include <sys/stat.h>
2677 int main(int argc, char*argv[])
2679 if(lchflags(argv[0], 0) != 0)
2683 ]], ac_cv_have_lchflags=yes,
2684 ac_cv_have_lchflags=no,
2685 ac_cv_have_lchflags=no)
2687 AC_MSG_RESULT($ac_cv_have_lchflags)
2688 if test $ac_cv_have_lchflags = yes
2690 AC_DEFINE(HAVE_LCHFLAGS, 1, Define to 1 if you have the `lchflags' function.)
2693 dnl Check if system zlib has *Copy() functions
2695 dnl On MacOSX the linker will search for dylibs on the entire linker path
2696 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2697 dnl to revert to a more traditional unix behaviour and make it possible to
2698 dnl override the system libz with a local static library of libz. Temporarily
2699 dnl add that flag to our CFLAGS as well to ensure that we check the version
2700 dnl of libz that will be used by setup.py.
2701 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2702 dnl environment as setup.py (and leaving it out can cause configure to use the
2703 dnl wrong version of the library)
2704 case $ac_sys_system/$ac_sys_release in
2706 _CUR_CFLAGS="${CFLAGS}"
2707 _CUR_LDFLAGS="${LDFLAGS}"
2708 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2709 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2713 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2715 case $ac_sys_system/$ac_sys_release in
2717 CFLAGS="${_CUR_CFLAGS}"
2718 LDFLAGS="${_CUR_LDFLAGS}"
2722 AC_MSG_CHECKING(for hstrerror)
2724 #include "confdefs.h"
2726 ], void* p = hstrerror; hstrerror(0),
2727 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2732 AC_MSG_CHECKING(for inet_aton)
2734 #include "confdefs.h"
2735 #include <sys/types.h>
2736 #include <sys/socket.h>
2737 #include <netinet/in.h>
2738 #include <arpa/inet.h>
2739 ], void* p = inet_aton;inet_aton(0,0),
2740 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2745 AC_MSG_CHECKING(for inet_pton)
2747 #include "confdefs.h"
2748 #include <sys/types.h>
2749 #include <sys/socket.h>
2750 #include <netinet/in.h>
2751 #include <arpa/inet.h>
2752 ], void* p = inet_pton,
2753 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2758 # On some systems, setgroups is in unistd.h, on others, in grp.h
2759 AC_MSG_CHECKING(for setgroups)
2761 #include "confdefs.h"
2767 void* p = setgroups,
2768 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2773 # check for openpty and forkpty
2775 AC_CHECK_FUNCS(openpty,,
2776 AC_CHECK_LIB(util,openpty,
2777 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2778 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2781 AC_CHECK_FUNCS(forkpty,,
2782 AC_CHECK_LIB(util,forkpty,
2783 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2784 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2789 AC_CHECK_FUNCS(memmove)
2791 # check for long file support functions
2792 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2794 AC_REPLACE_FUNCS(dup2 getcwd strdup)
2795 AC_CHECK_FUNCS(getpgrp,
2796 AC_TRY_COMPILE([#include <unistd.h>],
2798 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2799 [Define if getpgrp() must be called as getpgrp(0).])
2802 AC_CHECK_FUNCS(setpgrp,
2803 AC_TRY_COMPILE([#include <unistd.h>],
2805 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2806 [Define if setpgrp() must be called as setpgrp(0, 0).])
2809 AC_CHECK_FUNCS(gettimeofday,
2810 AC_TRY_COMPILE([#include <sys/time.h>],
2811 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2812 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2813 [Define if gettimeofday() does not have second (timezone) argument
2814 This is the case on Motorola V4 (R40V4.2)])
2818 AC_MSG_CHECKING(for major, minor, and makedev)
2820 #if defined(MAJOR_IN_MKDEV)
2821 #include <sys/mkdev.h>
2822 #elif defined(MAJOR_IN_SYSMACROS)
2823 #include <sys/sysmacros.h>
2825 #include <sys/types.h>
2828 makedev(major(0),minor(0));
2830 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2831 [Define to 1 if you have the device macros.])
2837 # On OSF/1 V5.1, getaddrinfo is available, but a define
2838 # for [no]getaddrinfo in netdb.h.
2839 AC_MSG_CHECKING(for getaddrinfo)
2841 #include <sys/types.h>
2842 #include <sys/socket.h>
2845 ], [getaddrinfo(NULL, NULL, NULL, NULL);],
2846 have_getaddrinfo=yes,
2847 have_getaddrinfo=no)
2848 AC_MSG_RESULT($have_getaddrinfo)
2849 if test $have_getaddrinfo = yes
2851 AC_MSG_CHECKING(getaddrinfo bug)
2852 AC_CACHE_VAL(ac_cv_buggy_getaddrinfo,
2854 #include <sys/types.h>
2857 #include <sys/socket.h>
2858 #include <netinet/in.h>
2862 int passive, gaierr, inet4 = 0, inet6 = 0;
2863 struct addrinfo hints, *ai, *aitop;
2864 char straddr[INET6_ADDRSTRLEN], strport[16];
2866 for (passive = 0; passive <= 1; passive++) {
2867 memset(&hints, 0, sizeof(hints));
2868 hints.ai_family = AF_UNSPEC;
2869 hints.ai_flags = passive ? AI_PASSIVE : 0;
2870 hints.ai_socktype = SOCK_STREAM;
2871 hints.ai_protocol = IPPROTO_TCP;
2872 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2873 (void)gai_strerror(gaierr);
2876 for (ai = aitop; ai; ai = ai->ai_next) {
2877 if (ai->ai_addr == NULL ||
2878 ai->ai_addrlen == 0 ||
2879 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2880 straddr, sizeof(straddr), strport, sizeof(strport),
2881 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2884 switch (ai->ai_family) {
2886 if (strcmp(strport, "54321") != 0) {
2890 if (strcmp(straddr, "0.0.0.0") != 0) {
2894 if (strcmp(straddr, "127.0.0.1") != 0) {
2901 if (strcmp(strport, "54321") != 0) {
2905 if (strcmp(straddr, "::") != 0) {
2909 if (strcmp(straddr, "::1") != 0) {
2919 /* another family support? */
2925 if (!(inet4 == 0 || inet4 == 2))
2927 if (!(inet6 == 0 || inet6 == 2))
2931 freeaddrinfo(aitop);
2936 freeaddrinfo(aitop);
2939 ]], ac_cv_buggy_getaddrinfo=no,
2940 ac_cv_buggy_getaddrinfo=yes,
2941 ac_cv_buggy_getaddrinfo=yes))
2944 if test $have_getaddrinfo = no -o $ac_cv_buggy_getaddrinfo = yes
2948 echo 'Fatal: You must get working getaddrinfo() function.'
2949 echo ' or you can specify "--disable-ipv6"'.
2953 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2955 AC_CHECK_FUNCS(getnameinfo)
2957 # checks for structures
2961 AC_CHECK_MEMBERS([struct stat.st_rdev])
2962 AC_CHECK_MEMBERS([struct stat.st_blksize])
2963 AC_CHECK_MEMBERS([struct stat.st_flags])
2964 AC_CHECK_MEMBERS([struct stat.st_gen])
2965 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2968 AC_MSG_CHECKING(for time.h that defines altzone)
2969 AC_CACHE_VAL(ac_cv_header_time_altzone,
2970 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2971 ac_cv_header_time_altzone=yes,
2972 ac_cv_header_time_altzone=no)])
2973 AC_MSG_RESULT($ac_cv_header_time_altzone)
2974 if test $ac_cv_header_time_altzone = yes; then
2975 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2979 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2981 #include <sys/types.h>
2982 #include <sys/select.h>
2983 #include <sys/time.h>
2985 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2986 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2987 (which you can't on SCO ODT 3.0).])
2990 AC_MSG_RESULT($was_it_defined)
2992 AC_MSG_CHECKING(for addrinfo)
2993 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2995 # include <netdb.h>],
2996 [struct addrinfo a],
2997 ac_cv_struct_addrinfo=yes,
2998 ac_cv_struct_addrinfo=no))
2999 AC_MSG_RESULT($ac_cv_struct_addrinfo)
3000 if test $ac_cv_struct_addrinfo = yes; then
3001 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
3004 AC_MSG_CHECKING(for sockaddr_storage)
3005 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
3007 # include <sys/types.h>
3008 # include <sys/socket.h>],
3009 [struct sockaddr_storage s],
3010 ac_cv_struct_sockaddr_storage=yes,
3011 ac_cv_struct_sockaddr_storage=no))
3012 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
3013 if test $ac_cv_struct_sockaddr_storage = yes; then
3014 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
3017 # checks for compiler characteristics
3023 AC_MSG_CHECKING(for working volatile)
3024 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
3025 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
3027 AC_MSG_RESULT($works)
3030 AC_MSG_CHECKING(for working signed char)
3031 AC_TRY_COMPILE([], [signed char c;], works=yes,
3032 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
3034 AC_MSG_RESULT($works)
3037 AC_MSG_CHECKING(for prototypes)
3038 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
3039 AC_DEFINE(HAVE_PROTOTYPES, 1,
3040 [Define if your compiler supports function prototype])
3043 AC_MSG_RESULT($have_prototypes)
3046 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
3049 int foo(int x, ...) {
3057 ], [return foo(10, "", 3.14);], [
3058 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
3059 [Define if your compiler supports variable length function prototypes
3060 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
3063 AC_MSG_RESULT($works)
3065 # check for socketpair
3066 AC_MSG_CHECKING(for socketpair)
3068 #include <sys/types.h>
3069 #include <sys/socket.h>
3070 ], void *x=socketpair,
3071 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
3076 # check if sockaddr has sa_len member
3077 AC_MSG_CHECKING(if sockaddr has sa_len member)
3078 AC_TRY_COMPILE([#include <sys/types.h>
3079 #include <sys/socket.h>],
3083 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
3087 AC_MSG_CHECKING(whether va_list is an array)
3089 #ifdef HAVE_STDARG_PROTOTYPES
3092 #include <varargs.h>
3094 ], [va_list list1, list2; list1 = list2;], , [
3095 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
3096 va_list_is_array=yes
3098 AC_MSG_RESULT($va_list_is_array)
3100 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
3101 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
3102 [Define this if you have some version of gethostbyname_r()])
3104 AC_CHECK_FUNC(gethostbyname_r, [
3105 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3106 AC_MSG_CHECKING([gethostbyname_r with 6 args])
3108 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
3113 struct hostent *he, *res;
3118 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
3120 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3121 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
3122 [Define this if you have the 6-arg version of gethostbyname_r().])
3126 AC_MSG_CHECKING([gethostbyname_r with 5 args])
3136 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
3138 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3139 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
3140 [Define this if you have the 5-arg version of gethostbyname_r().])
3144 AC_MSG_CHECKING([gethostbyname_r with 3 args])
3150 struct hostent_data data;
3152 (void) gethostbyname_r(name, he, &data);
3154 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3155 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
3156 [Define this if you have the 3-arg version of gethostbyname_r().])
3165 AC_CHECK_FUNCS(gethostbyname)
3167 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
3168 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
3169 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
3170 AC_SUBST(HAVE_GETHOSTBYNAME_R)
3171 AC_SUBST(HAVE_GETHOSTBYNAME)
3173 # checks for system services
3176 # Linux requires this for correct f.p. operations
3177 AC_CHECK_FUNC(__fpu_control,
3179 [AC_CHECK_LIB(ieee, __fpu_control)
3182 # Check for --with-fpectl
3183 AC_MSG_CHECKING(for --with-fpectl)
3185 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
3187 if test "$withval" != no
3189 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
3190 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
3192 else AC_MSG_RESULT(no)
3194 [AC_MSG_RESULT(no)])
3196 # check for --with-libm=...
3198 case $ac_sys_system in
3203 AC_MSG_CHECKING(for --with-libm=STRING)
3205 AC_HELP_STRING(--with-libm=STRING, math library),
3207 if test "$withval" = no
3209 AC_MSG_RESULT(force LIBM empty)
3210 elif test "$withval" != yes
3212 AC_MSG_RESULT(set LIBM="$withval")
3213 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
3215 [AC_MSG_RESULT(default LIBM="$LIBM")])
3217 # check for --with-libc=...
3219 AC_MSG_CHECKING(for --with-libc=STRING)
3221 AC_HELP_STRING(--with-libc=STRING, C library),
3223 if test "$withval" = no
3225 AC_MSG_RESULT(force LIBC empty)
3226 elif test "$withval" != yes
3228 AC_MSG_RESULT(set LIBC="$withval")
3229 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
3231 [AC_MSG_RESULT(default LIBC="$LIBC")])
3233 # ************************************
3234 # * Check for mathematical functions *
3235 # ************************************
3240 # Detect whether system arithmetic is subject to x87-style double
3241 # rounding issues. The result of this test has little meaning on non
3242 # IEEE 754 platforms. On IEEE 754, test should return 1 if rounding
3243 # mode is round-to-nearest and double rounding issues are present, and
3244 # 0 otherwise. See http://bugs.python.org/issue2937 for more info.
3245 AC_MSG_CHECKING(for x87-style double rounding)
3246 AC_CACHE_VAL(ac_cv_x87_double_rounding, [
3251 volatile double x, y, z;
3252 /* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */
3253 x = 0.99999999999999989; /* 1-2**-53 */
3257 /* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
3263 /* both tests show evidence of double rounding */
3267 ac_cv_x87_double_rounding=no,
3268 ac_cv_x87_double_rounding=yes,
3269 ac_cv_x87_double_rounding=no)])
3270 AC_MSG_RESULT($ac_cv_x87_double_rounding)
3271 if test "$ac_cv_x87_double_rounding" = yes
3273 AC_DEFINE(X87_DOUBLE_ROUNDING, 1,
3274 [Define if arithmetic is subject to x87-style double rounding issue])
3277 # Multiprocessing check for broken sem_getvalue
3278 AC_MSG_CHECKING(for broken sem_getvalue)
3279 AC_CACHE_VAL(ac_cv_broken_sem_getvalue,
3284 #include <semaphore.h>
3285 #include <sys/stat.h>
3288 sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR|S_IWUSR, 0);
3296 res = sem_getvalue(a, &count);
3298 return res==-1 ? 1 : 0;
3300 ], ac_cv_broken_sem_getvalue=no,
3301 ac_cv_broken_sem_getvalue=yes,
3302 ac_cv_broken_sem_getvalue=yes)
3304 AC_MSG_RESULT($ac_cv_broken_sem_getvalue)
3305 if test $ac_cv_broken_sem_getvalue = yes
3307 AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1,
3308 [define to 1 if your sem_getvalue is broken.])
3311 # On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
3312 # -0. on some architectures.
3313 AC_MSG_CHECKING(whether tanh preserves the sign of zero)
3314 AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
3319 /* return 0 if either negative zeros don't exist
3320 on this platform or if negative zeros exist
3321 and tanh(-0.) == -0. */
3322 if (atan2(0., -1.) == atan2(-0., -1.) ||
3323 atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
3327 ac_cv_tanh_preserves_zero_sign=yes,
3328 ac_cv_tanh_preserves_zero_sign=no,
3329 ac_cv_tanh_preserves_zero_sign=no)])
3330 AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
3331 if test "$ac_cv_tanh_preserves_zero_sign" = yes
3333 AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
3334 [Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
3337 AC_CHECK_FUNCS([acosh asinh atanh copysign erf erfc expm1 finite gamma])
3338 AC_CHECK_FUNCS([hypot lgamma log1p round tgamma])
3339 AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]])
3343 # determine what size digit to use for Python's longs
3344 AC_MSG_CHECKING([digit size for Python's longs])
3345 AC_ARG_ENABLE(big-digits,
3346 AC_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
3347 [case $enable_big_digits in
3349 enable_big_digits=30 ;;
3351 enable_big_digits=15 ;;
3355 AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
3357 AC_MSG_RESULT($enable_big_digits)
3358 AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits])
3360 [AC_MSG_RESULT(no value specified)])
3363 AC_CHECK_HEADER(wchar.h, [
3364 AC_DEFINE(HAVE_WCHAR_H, 1,
3365 [Define if the compiler provides a wchar.h header file.])
3371 # determine wchar_t size
3372 if test "$wchar_h" = yes
3374 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
3377 AC_MSG_CHECKING(for UCS-4 tcl)
3381 #if TCL_UTF_MAX != 6
3382 # error "NOT UCS4_TCL"
3384 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
3387 AC_MSG_RESULT($have_ucs4_tcl)
3389 # check whether wchar_t is signed or not
3390 if test "$wchar_h" = yes
3392 # check whether wchar_t is signed or not
3393 AC_MSG_CHECKING(whether wchar_t is signed)
3394 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
3399 /* Success: exit code 0 */
3400 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
3403 ac_cv_wchar_t_signed=yes,
3404 ac_cv_wchar_t_signed=no,
3405 ac_cv_wchar_t_signed=yes)])
3406 AC_MSG_RESULT($ac_cv_wchar_t_signed)
3409 AC_MSG_CHECKING(what type to use for unicode)
3410 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
3411 AC_ARG_ENABLE(unicode,
3412 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
3414 [enable_unicode=yes])
3416 if test $enable_unicode = yes
3418 # Without any arguments, Py_UNICODE defaults to two-byte mode
3419 case "$have_ucs4_tcl" in
3420 yes) enable_unicode="ucs4"
3422 *) enable_unicode="ucs2"
3427 AH_TEMPLATE(Py_UNICODE_SIZE,
3428 [Define as the size of the unicode type.])
3429 case "$enable_unicode" in
3430 ucs2) unicode_size="2"
3431 AC_DEFINE(Py_UNICODE_SIZE,2)
3433 ucs4) unicode_size="4"
3434 AC_DEFINE(Py_UNICODE_SIZE,4)
3438 AH_TEMPLATE(PY_UNICODE_TYPE,
3439 [Define as the integral type used for Unicode representation.])
3441 AC_SUBST(UNICODE_OBJS)
3442 if test "$enable_unicode" = "no"
3445 AC_MSG_RESULT(not used)
3447 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
3448 AC_DEFINE(Py_USING_UNICODE, 1,
3449 [Define if you want to have a Unicode type.])
3451 # wchar_t is only usable if it maps to an unsigned type
3452 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3453 -a "$ac_cv_wchar_t_signed" = "no"
3455 PY_UNICODE_TYPE="wchar_t"
3456 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3457 [Define if you have a useable wchar_t type defined in wchar.h; useable
3458 means wchar_t must be an unsigned type with at least 16 bits. (see
3459 Include/unicodeobject.h).])
3460 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3461 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3463 PY_UNICODE_TYPE="unsigned short"
3464 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3465 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3467 PY_UNICODE_TYPE="unsigned long"
3468 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3470 PY_UNICODE_TYPE="no type found"
3472 AC_MSG_RESULT($PY_UNICODE_TYPE)
3475 # check for endianness
3478 # Check whether right shifting a negative integer extends the sign bit
3479 # or fills with zeros (like the Cray J90, according to Tim Peters).
3480 AC_MSG_CHECKING(whether right shift extends the sign bit)
3481 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3485 exit(((-1)>>3 == -1) ? 0 : 1);
3488 ac_cv_rshift_extends_sign=yes,
3489 ac_cv_rshift_extends_sign=no,
3490 ac_cv_rshift_extends_sign=yes)])
3491 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3492 if test "$ac_cv_rshift_extends_sign" = no
3494 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3495 [Define if i>>j for signed int i does not extend the sign bit
3499 # check for getc_unlocked and related locking functions
3500 AC_MSG_CHECKING(for getc_unlocked() and friends)
3501 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3502 AC_TRY_LINK([#include <stdio.h>],[
3503 FILE *f = fopen("/dev/null", "r");
3507 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3508 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3509 if test "$ac_cv_have_getc_unlocked" = yes
3511 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3512 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3515 # check where readline lives
3516 # save the value of LIBS so we don't actually link Python with readline
3517 LIBS_no_readline=$LIBS
3519 # On some systems we need to link readline to a termcap compatible
3520 # library. NOTE: Keep the precedence of listed libraries synchronised
3522 py_cv_lib_readline=no
3523 AC_MSG_CHECKING([how to link readline libs])
3524 for py_libtermcap in "" ncursesw ncurses curses termcap; do
3525 if test -z "$py_libtermcap"; then
3526 READLINE_LIBS="-lreadline"
3528 READLINE_LIBS="-lreadline -l$py_libtermcap"
3530 LIBS="$READLINE_LIBS $LIBS_no_readline"
3532 [AC_LANG_CALL([],[readline])],
3533 [py_cv_lib_readline=yes])
3534 if test $py_cv_lib_readline = yes; then
3538 # Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
3539 #AC_SUBST([READLINE_LIBS])
3540 if test $py_cv_lib_readline = no; then
3541 AC_MSG_RESULT([none])
3543 AC_MSG_RESULT([$READLINE_LIBS])
3544 AC_DEFINE(HAVE_LIBREADLINE, 1,
3545 [Define if you have the readline library (-lreadline).])
3548 # check for readline 2.1
3549 AC_CHECK_LIB(readline, rl_callback_handler_install,
3550 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3551 [Define if you have readline 2.1]), ,$READLINE_LIBS)
3553 # check for readline 2.2
3554 AC_TRY_CPP([#include <readline/readline.h>],
3555 have_readline=yes, have_readline=no)
3556 if test $have_readline = yes
3558 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3559 [readline/readline.h],
3560 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3561 [Define if you have readline 2.2]), )
3564 # check for readline 4.0
3565 AC_CHECK_LIB(readline, rl_pre_input_hook,
3566 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3567 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3570 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
3571 AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
3572 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3574 # check for readline 4.2
3575 AC_CHECK_LIB(readline, rl_completion_matches,
3576 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3577 [Define if you have readline 4.2]), ,$READLINE_LIBS)
3579 # also in readline 4.2
3580 AC_TRY_CPP([#include <readline/readline.h>],
3581 have_readline=yes, have_readline=no)
3582 if test $have_readline = yes
3584 AC_EGREP_HEADER([extern int rl_catch_signals;],
3585 [readline/readline.h],
3586 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3587 [Define if you can turn off readline's signal handling.]), )
3590 # End of readline checks: restore LIBS
3591 LIBS=$LIBS_no_readline
3593 AC_MSG_CHECKING(for broken nice())
3594 AC_CACHE_VAL(ac_cv_broken_nice, [
3599 if (val1 != -1 && val1 == nice(2))
3604 ac_cv_broken_nice=yes,
3605 ac_cv_broken_nice=no,
3606 ac_cv_broken_nice=no)])
3607 AC_MSG_RESULT($ac_cv_broken_nice)
3608 if test "$ac_cv_broken_nice" = yes
3610 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3611 [Define if nice() returns success/failure instead of the new priority.])
3614 AC_MSG_CHECKING(for broken poll())
3615 AC_CACHE_VAL(ac_cv_broken_poll,
3621 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3626 poll_test = poll(&poll_struct, 1, 0);
3629 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3635 ac_cv_broken_poll=yes,
3636 ac_cv_broken_poll=no,
3637 ac_cv_broken_poll=no))
3638 AC_MSG_RESULT($ac_cv_broken_poll)
3639 if test "$ac_cv_broken_poll" = yes
3641 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3642 [Define if poll() sets errno on invalid file descriptors.])
3645 # Before we can test tzset, we need to check if struct tm has a tm_zone
3646 # (which is not required by ISO C or UNIX spec) and/or if we support
3650 # check tzset(3) exists and works like we expect it to
3651 AC_MSG_CHECKING(for working tzset())
3652 AC_CACHE_VAL(ac_cv_working_tzset, [
3659 extern char *tzname[];
3664 /* Note that we need to ensure that not only does tzset(3)
3665 do 'something' with localtime, but it works as documented
3666 in the library reference and as expected by the test suite.
3667 This includes making sure that tzname is set properly if
3668 tm->tm_zone does not exist since it is the alternative way
3669 of getting timezone info.
3671 Red Hat 6.2 doesn't understand the southern hemisphere
3672 after New Year's Day.
3675 time_t groundhogday = 1044144000; /* GMT-based */
3676 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3680 if (localtime(&groundhogday)->tm_hour != 0)
3683 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3684 if (strcmp(tzname[0], "UTC") ||
3685 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3689 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3691 if (localtime(&groundhogday)->tm_hour != 19)
3694 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3698 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3700 if (localtime(&groundhogday)->tm_hour != 11)
3703 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3707 #if HAVE_STRUCT_TM_TM_ZONE
3708 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3710 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3717 ac_cv_working_tzset=yes,
3718 ac_cv_working_tzset=no,
3719 ac_cv_working_tzset=no)])
3720 AC_MSG_RESULT($ac_cv_working_tzset)
3721 if test "$ac_cv_working_tzset" = yes
3723 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3724 [Define if tzset() actually switches the local timezone in a meaningful way.])
3727 # Look for subsecond timestamps in struct stat
3728 AC_MSG_CHECKING(for tv_nsec in struct stat)
3729 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3730 AC_TRY_COMPILE([#include <sys/stat.h>], [
3732 st.st_mtim.tv_nsec = 1;
3734 ac_cv_stat_tv_nsec=yes,
3735 ac_cv_stat_tv_nsec=no,
3736 ac_cv_stat_tv_nsec=no))
3737 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3738 if test "$ac_cv_stat_tv_nsec" = yes
3740 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3741 [Define if you have struct stat.st_mtim.tv_nsec])
3744 # Look for BSD style subsecond timestamps in struct stat
3745 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3746 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3747 AC_TRY_COMPILE([#include <sys/stat.h>], [
3749 st.st_mtimespec.tv_nsec = 1;
3751 ac_cv_stat_tv_nsec2=yes,
3752 ac_cv_stat_tv_nsec2=no,
3753 ac_cv_stat_tv_nsec2=no))
3754 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3755 if test "$ac_cv_stat_tv_nsec2" = yes
3757 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3758 [Define if you have struct stat.st_mtimensec])
3761 # On HP/UX 11.0, mvwdelch is a block with a return statement
3762 AC_MSG_CHECKING(whether mvwdelch is an expression)
3763 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3764 AC_TRY_COMPILE([#include <curses.h>], [
3766 rtn = mvwdelch(0,0,0);
3767 ], ac_cv_mvwdelch_is_expression=yes,
3768 ac_cv_mvwdelch_is_expression=no,
3769 ac_cv_mvwdelch_is_expression=yes))
3770 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3772 if test "$ac_cv_mvwdelch_is_expression" = yes
3774 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3775 [Define if mvwdelch in curses.h is an expression.])
3778 AC_MSG_CHECKING(whether WINDOW has _flags)
3779 AC_CACHE_VAL(ac_cv_window_has_flags,
3780 AC_TRY_COMPILE([#include <curses.h>], [
3783 ], ac_cv_window_has_flags=yes,
3784 ac_cv_window_has_flags=no,
3785 ac_cv_window_has_flags=no))
3786 AC_MSG_RESULT($ac_cv_window_has_flags)
3789 if test "$ac_cv_window_has_flags" = yes
3791 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3792 [Define if WINDOW in curses.h offers a field _flags.])
3795 AC_MSG_CHECKING(for is_term_resized)
3796 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3797 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3802 AC_MSG_CHECKING(for resize_term)
3803 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3804 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3809 AC_MSG_CHECKING(for resizeterm)
3810 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3811 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3816 AC_MSG_CHECKING(for /dev/ptmx)
3818 if test -r /dev/ptmx
3821 AC_DEFINE(HAVE_DEV_PTMX, 1,
3822 [Define if we have /dev/ptmx.])
3827 AC_MSG_CHECKING(for /dev/ptc)
3832 AC_DEFINE(HAVE_DEV_PTC, 1,
3833 [Define if we have /dev/ptc.])
3838 AC_MSG_CHECKING(for %zd printf() format support)
3839 AC_CACHE_VAL(ac_cv_have_size_t_format,
3845 #ifdef HAVE_SYS_TYPES_H
3846 #include <sys/types.h>
3850 typedef ssize_t Py_ssize_t;
3851 #elif SIZEOF_VOID_P == SIZEOF_LONG
3852 typedef long Py_ssize_t;
3854 typedef int Py_ssize_t;
3861 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3864 if (strcmp(buffer, "123"))
3867 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3870 if (strcmp(buffer, "-123"))
3875 ]], ac_cv_have_size_t_format=yes,
3876 ac_cv_have_size_t_format=no,
3877 ac_cv_have_size_t_format=no)
3879 AC_MSG_RESULT($ac_cv_have_size_t_format)
3880 if test $ac_cv_have_size_t_format = yes
3882 AC_DEFINE(PY_FORMAT_SIZE_T, "z",
3883 [Define to printf format modifier for Py_ssize_t])
3886 AC_CHECK_TYPE(socklen_t,,
3887 AC_DEFINE(socklen_t,int,
3888 Define to `int' if <sys/socket.h> does not define.),[
3889 #ifdef HAVE_SYS_TYPES_H
3890 #include <sys/types.h>
3892 #ifdef HAVE_SYS_SOCKET_H
3893 #include <sys/socket.h>
3897 AC_SUBST(THREADHEADERS)
3899 for h in `(cd $srcdir;echo Python/thread_*.h)`
3901 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3905 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3906 AC_MSG_CHECKING(for build directories)
3907 for dir in $SRCDIRS; do
3908 if test ! -d $dir; then
3914 # generate output files
3915 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config Misc/python.pc)
3918 echo "creating Modules/Setup"
3919 if test ! -f Modules/Setup
3921 cp $srcdir/Modules/Setup.dist Modules/Setup
3924 echo "creating Modules/Setup.local"
3925 if test ! -f Modules/Setup.local
3927 echo "# Edit this file for local setup changes" >Modules/Setup.local
3930 echo "creating Makefile"
3931 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3932 -s Modules Modules/Setup.config \
3933 Modules/Setup.local Modules/Setup
3935 case $ac_sys_system in
3939 Support for BeOS is deprecated as of Python 2.6.
3940 See PEP 11 for the gory details.