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 AC_REVISION($Revision$)
11 AC_INIT(python, PYTHON_VERSION, http://www.python.org/python-bugs)
12 AC_CONFIG_SRCDIR([Include/object.h])
13 AC_CONFIG_HEADER(pyconfig.h)
15 dnl Ensure that if prefix is specified, it does not end in a slash. If
16 dnl it does, we get path names containing '//' which is both ugly and
17 dnl can cause trouble.
19 dnl Last slash shouldn't be stripped if prefix=/
20 if test "$prefix" != "/"; then
21 prefix=`echo "$prefix" | sed -e 's/\/$//g'`
24 dnl This is for stuff that absolutely must end up in pyconfig.h.
25 dnl Please use pyport.h instead, if possible.
31 /* Define the macros needed if on a UnixWare 7.x system. */
32 #if defined(__USLC__) && defined(__SCO_VERSION__)
33 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
36 #endif /*Py_PYCONFIG_H*/
39 # We don't use PACKAGE_ variables, and they cause conflicts
40 # with other autoconf-based packages that include Python.h
41 grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
43 mv confdefs.h.new confdefs.h
46 VERSION=PYTHON_VERSION
51 # The later defininition of _XOPEN_SOURCE disables certain features
52 # on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
53 AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])
55 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
56 # certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
58 AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])
60 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
61 # certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
63 AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])
65 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
66 # u_int on Irix 5.3. Defining _BSD_TYPES brings it back.
67 AC_DEFINE(_BSD_TYPES, 1, [Define on Irix to enable u_int])
69 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
70 # certain features on Mac OS X, so we need _DARWIN_C_SOURCE to re-enable
72 AC_DEFINE(_DARWIN_C_SOURCE, 1, [Define on Darwin to activate all library features])
75 define_xopen_source=yes
77 # Arguments passed to configure.
79 CONFIG_ARGS="$ac_configure_args"
81 AC_ARG_ENABLE(universalsdk,
82 AC_HELP_STRING(--enable-universalsdk@<:@=SDKDIR@:>@, Build against Mac OS X 10.4u SDK (ppc/i386)),
86 enableval=/Developer/SDKs/MacOSX10.4u.sdk
95 UNIVERSALSDK=$enableval
102 AC_SUBST(UNIVERSALSDK)
105 AC_SUBST(ARCH_RUN_32BIT)
107 UNIVERSAL_ARCHS="32-bit"
108 AC_MSG_CHECKING(for --with-universal-archs)
109 AC_ARG_WITH(universal-archs,
110 AC_HELP_STRING(--with-universal-archs=ARCH, select architectures for universal build ("32-bit", "64-bit" or "all")),
112 AC_MSG_RESULT($withval)
113 UNIVERSAL_ARCHS="$withval"
116 AC_MSG_RESULT(32-bit)
121 AC_ARG_WITH(framework-name,
122 AC_HELP_STRING(--with-framework-name=FRAMEWORK,
123 specify an alternate name of the framework built with --enable-framework),
125 PYTHONFRAMEWORK=${withval}
126 PYTHONFRAMEWORKDIR=${withval}.framework
127 PYTHONFRAMEWORKIDENTIFIER=org.python.`echo $withval | tr '[A-Z]' '[a-z]'`
129 PYTHONFRAMEWORK=Python
130 PYTHONFRAMEWORKDIR=Python.framework
131 PYTHONFRAMEWORKIDENTIFIER=org.python.python
133 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
134 AC_ARG_ENABLE(framework,
135 AC_HELP_STRING(--enable-framework@<:@=INSTALLDIR@:>@, Build (MacOSX|Darwin) framework),
139 enableval=/Library/Frameworks
144 PYTHONFRAMEWORKDIR=no-framework
145 PYTHONFRAMEWORKPREFIX=
146 PYTHONFRAMEWORKINSTALLDIR=
147 FRAMEWORKINSTALLFIRST=
148 FRAMEWORKINSTALLLAST=
149 FRAMEWORKALTINSTALLFIRST=
150 FRAMEWORKALTINSTALLLAST=
151 if test "x${prefix}" = "xNONE"; then
152 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
154 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
159 PYTHONFRAMEWORKPREFIX=$enableval
160 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
161 FRAMEWORKINSTALLFIRST="frameworkinstallstructure"
162 FRAMEWORKALTINSTALLFIRST="frameworkinstallstructure bininstall maninstall"
163 if test "$UNIVERSAL_ARCHS" = "all"
165 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps4way frameworkinstallunixtools4way"
166 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps4way frameworkaltinstallunixtools4way"
168 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools"
169 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkaltinstallunixtools"
172 if test "x${prefix}" = "xNONE" ; then
173 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
175 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
177 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
179 # Add files for Mac specific code to the list of output
181 AC_CONFIG_FILES(Mac/Makefile)
182 AC_CONFIG_FILES(Mac/PythonLauncher/Makefile)
183 AC_CONFIG_FILES(Mac/IDLE/Makefile)
184 AC_CONFIG_FILES(Mac/Resources/framework/Info.plist)
185 AC_CONFIG_FILES(Mac/Resources/app/Info.plist)
189 PYTHONFRAMEWORKDIR=no-framework
190 PYTHONFRAMEWORKPREFIX=
191 PYTHONFRAMEWORKINSTALLDIR=
192 FRAMEWORKINSTALLFIRST=
193 FRAMEWORKINSTALLLAST=
194 FRAMEWORKALTINSTALLFIRST=
195 FRAMEWORKALTINSTALLLAST=
196 if test "x${prefix}" = "xNONE" ; then
197 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
199 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
203 if test "$UNIVERSAL_ARCHS" = "all"
205 FRAMEWORKINSTALLLAST=update4wayuniversal
206 FRAMEWORKALTINSTALLLAST=update4wayuniversal
209 AC_SUBST(PYTHONFRAMEWORK)
210 AC_SUBST(PYTHONFRAMEWORKIDENTIFIER)
211 AC_SUBST(PYTHONFRAMEWORKDIR)
212 AC_SUBST(PYTHONFRAMEWORKPREFIX)
213 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
214 AC_SUBST(FRAMEWORKINSTALLFIRST)
215 AC_SUBST(FRAMEWORKINSTALLLAST)
216 AC_SUBST(FRAMEWORKALTINSTALLFIRST)
217 AC_SUBST(FRAMEWORKALTINSTALLLAST)
218 AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX)
221 ## AC_HELP_STRING(--with-dyld,
222 ## Use (OpenStep|Rhapsody) dynamic linker))
224 # Set name for machine-dependent library files
226 AC_MSG_CHECKING(MACHDEP)
227 if test -z "$MACHDEP"
229 ac_sys_system=`uname -s`
230 if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64" \
231 -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
232 ac_sys_release=`uname -v`
234 ac_sys_release=`uname -r`
236 ac_md_system=`echo $ac_sys_system |
237 tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
238 ac_md_release=`echo $ac_sys_release |
239 tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
240 MACHDEP="$ac_md_system$ac_md_release"
243 cygwin*) MACHDEP="cygwin";;
244 darwin*) MACHDEP="darwin";;
245 atheos*) MACHDEP="atheos";;
246 irix646) MACHDEP="irix6";;
247 '') MACHDEP="unknown";;
251 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
252 # disable features if it is defined, without any means to access these
253 # features as extensions. For these systems, we skip the definition of
254 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
255 # some feature, make sure there is no alternative way to access this
256 # feature. Also, when using wildcards, make sure you have verified the
257 # need for not defining _XOPEN_SOURCE on all systems matching the
258 # wildcard, and that the wildcard does not include future systems
259 # (which may remove their limitations).
260 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
261 case $ac_sys_system/$ac_sys_release in
262 # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
263 # even though select is a POSIX function. Reported by J. Ribbens.
264 # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
265 OpenBSD/2.* | OpenBSD/3.@<:@0123456789@:>@ | OpenBSD/4.@<:@0123@:>@)
266 define_xopen_source=no
267 # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
268 # also defined. This can be overridden by defining _BSD_SOURCE
269 # As this has a different meaning on Linux, only define it on OpenBSD
270 AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
272 # Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
273 # _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
275 NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6@<:@A-S@:>@)
276 define_xopen_source=no;;
277 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
278 # of union __?sigval. Reported by Stuart Bishop.
280 define_xopen_source=no;;
281 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
282 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
283 # Reconfirmed for 7.1.4 by Martin v. Loewis.
284 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
285 define_xopen_source=no;;
286 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
287 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
289 define_xopen_source=no;;
290 # On FreeBSD 4, the math functions C89 does not cover are never defined
291 # with _XOPEN_SOURCE and __BSD_VISIBLE does not re-enable them.
293 define_xopen_source=no;;
294 # On MacOS X 10.2, a bug in ncurses.h means that it craps out if
295 # _XOPEN_EXTENDED_SOURCE is defined. Apparently, this is fixed in 10.3, which
296 # identifies itself as Darwin/7.*
297 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
298 # disables platform specific features beyond repair.
299 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
300 # has no effect, don't bother defining them
301 Darwin/@<:@6789@:>@.*)
302 define_xopen_source=no;;
303 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
304 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
305 # or has another value. By not (re)defining it, the defaults come in place.
307 define_xopen_source=no;;
309 if test `uname -r` -eq 1; then
310 define_xopen_source=no
313 # On QNX 6.3.2, defining _XOPEN_SOURCE prevents netdb.h from
314 # defining NI_NUMERICHOST.
316 define_xopen_source=no
321 if test $define_xopen_source = yes
323 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
324 # defined precisely as g++ defines it
325 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
327 case $ac_sys_system/$ac_sys_release in
328 SunOS/5.8|SunOS/5.9|SunOS/5.10)
329 AC_DEFINE(_XOPEN_SOURCE, 500,
330 Define to the level of X/Open that your system supports)
333 AC_DEFINE(_XOPEN_SOURCE, 600,
334 Define to the level of X/Open that your system supports)
338 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
339 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
340 # several APIs are not declared. Since this is also needed in some
341 # cases for HP-UX, we define it globally.
342 # except for Solaris 10, where it must not be defined,
343 # as it implies XPG4.2
344 case $ac_sys_system/$ac_sys_release in
348 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
349 Define to activate Unix95-and-earlier features)
353 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
358 # SGI compilers allow the specification of the both the ABI and the
359 # ISA on the command line. Depending on the values of these switches,
360 # different and often incompatable code will be generated.
362 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
363 # thus supply support for various ABI/ISA combinations. The MACHDEP
364 # variable is also adjusted.
367 if test ! -z "$SGI_ABI"
370 LDFLAGS="$SGI_ABI $LDFLAGS"
371 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
373 AC_MSG_RESULT($MACHDEP)
375 # And add extra plat-mac for darwin
376 AC_SUBST(EXTRAPLATDIR)
377 AC_SUBST(EXTRAMACHDEPPATH)
378 AC_MSG_CHECKING(EXTRAPLATDIR)
379 if test -z "$EXTRAPLATDIR"
383 EXTRAPLATDIR="\$(PLATMACDIRS)"
384 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
392 AC_MSG_RESULT($EXTRAPLATDIR)
394 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
395 # it may influence the way we can build extensions, so distutils
397 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
398 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
399 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
400 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
402 AC_MSG_CHECKING(machine type as reported by uname -m)
403 ac_sys_machine=`uname -m`
404 AC_MSG_RESULT($ac_sys_machine)
406 # checks for alternative programs
408 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
409 # for debug/optimization stuff. BASECFLAGS is for flags that are required
410 # just to get things to compile and link. Users are free to override OPT
411 # when running configure or make. The build should not break if they do.
412 # BASECFLAGS should generally not be messed with, however.
414 # XXX shouldn't some/most/all of this code be merged with the stuff later
415 # on that fiddles with OPT and BASECFLAGS?
416 AC_MSG_CHECKING(for --without-gcc)
418 AC_HELP_STRING(--without-gcc,never use gcc),
426 without_gcc=$withval;;
428 case $ac_sys_system in
436 BASECFLAGS="$BASECFLAGS -export pragma"
438 LDFLAGS="$LDFLAGS -nodup"
446 AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
449 AR="\$(srcdir)/Modules/ar_beos"
457 AC_MSG_RESULT($without_gcc)
459 # If the user switches compilers, we can't believe the cache
460 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
462 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
463 (it is also a good idea to do 'make clean' before compiling)])
470 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
471 AC_ARG_WITH(cxx_main,
472 AC_HELP_STRING([--with-cxx-main=<compiler>],
473 [compile main() and link python executable with C++ compiler]),
479 yes) with_cxx_main=yes
491 AC_MSG_RESULT($with_cxx_main)
497 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
498 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
500 if test "$CXX" = "notfound"
507 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
508 if test "$CXX" = "notfound"
513 if test "$preset_cxx" != "$CXX"
517 By default, distutils will build C++ extension modules with "$CXX".
518 If this is not intended, then set CXX on the configure command line.
523 # checks for UNIX variants that set C preprocessor variables
526 # Check for unsupported systems
527 case $ac_sys_system/$ac_sys_release in
529 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
530 echo See README for details.
535 AC_MSG_CHECKING(for --with-suffix)
537 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
544 AC_MSG_RESULT($EXEEXT)
546 # Test whether we're running on a non-case-sensitive system, in which
547 # case we give a warning if no ext is given
548 AC_SUBST(BUILDEXEEXT)
549 AC_MSG_CHECKING(for case-insensitive build directory)
550 if test ! -d CaseSensitiveTestDir; then
551 mkdir CaseSensitiveTestDir
554 if test -d casesensitivetestdir
562 rmdir CaseSensitiveTestDir
567 gcc) CC="$CC -D_HAVE_BSDI";;
571 case $ac_sys_system in
574 cc|*/cc) CC="$CC -Ae";;
578 cc) CC="$CC -Wl,-Bexport";;
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 LINKCC="$LINKCC -L/usr/lib/ia64l64";;
643 # qcc must be used because the other compilers do not
648 AC_MSG_RESULT($LINKCC)
650 AC_MSG_CHECKING(for --enable-shared)
651 AC_ARG_ENABLE(shared,
652 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
654 if test -z "$enable_shared"
656 case $ac_sys_system in
658 enable_shared="yes";;
663 AC_MSG_RESULT($enable_shared)
665 AC_MSG_CHECKING(for --enable-profiling)
666 AC_ARG_ENABLE(profiling,
667 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
670 AC_TRY_RUN([int main() { return 0; }],
671 ac_enable_profiling="yes",
672 ac_enable_profiling="no",
673 ac_enable_profiling="no")
675 AC_MSG_RESULT($ac_enable_profiling)
677 case "$ac_enable_profiling" in
679 BASECFLAGS="-pg $BASECFLAGS"
680 LDFLAGS="-pg $LDFLAGS"
684 AC_MSG_CHECKING(LDLIBRARY)
686 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
687 # library that we build, but we do not want to link against it (we
688 # will find it with a -framework option). For this reason there is an
689 # extra variable BLDLIBRARY against which Python and the extension
690 # modules are linked, BLDLIBRARY. This is normally the same as
691 # LDLIBRARY, but empty for MacOSX framework builds.
692 if test "$enable_framework"
694 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
695 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
698 BLDLIBRARY='$(LDLIBRARY)'
701 # Other platforms follow
702 if test $enable_shared = "yes"; then
703 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
704 case $ac_sys_system in
706 LDLIBRARY='libpython$(VERSION).so'
709 LDLIBRARY='libpython$(VERSION).dll.a'
710 DLLLIBRARY='libpython$(VERSION).dll'
713 LDLIBRARY='libpython$(VERSION).so'
714 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
715 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
716 INSTSONAME="$LDLIBRARY".$SOVERSION
718 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
719 LDLIBRARY='libpython$(VERSION).so'
720 BLDLIBRARY='-L. -lpython$(VERSION)'
721 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
722 case $ac_sys_system in
724 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
727 INSTSONAME="$LDLIBRARY".$SOVERSION
732 LDLIBRARY='libpython$(VERSION).so'
735 LDLIBRARY='libpython$(VERSION).sl'
738 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
739 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
742 LDLIBRARY='libpython$(VERSION).so'
743 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
744 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
747 LDLIBRARY='libpython$(VERSION).so'
748 BLDLIBRARY='-L. -lpython$(VERSION)'
749 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
752 LDLIBRARY='libpython$(VERSION).dylib'
753 BLDLIBRARY='-L. -lpython$(VERSION)'
754 RUNSHARED='DYLD_LIBRARY_PATH=`pwd`:${DYLD_LIBRARY_PATH}'
758 else # shared is disabled
759 case $ac_sys_system in
761 BLDLIBRARY='$(LIBRARY)'
762 LDLIBRARY='libpython$(VERSION).dll.a'
767 AC_MSG_RESULT($LDLIBRARY)
771 AC_CHECK_PROGS(AR, ar aal, ar)
774 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
775 if test $SVNVERSION = found
777 SVNVERSION="svnversion \$(srcdir)"
779 SVNVERSION="echo exported"
784 # install -d does not work on BSDI or HP-UX
785 if test -z "$INSTALL"
787 INSTALL="${srcdir}/install-sh -c"
792 # Not every filesystem supports hard links
794 if test -z "$LN" ; then
795 case $ac_sys_system in
797 CYGWIN*) LN="ln -s";;
798 atheos*) LN="ln -s";;
803 # Check for --with-pydebug
804 AC_MSG_CHECKING(for --with-pydebug)
806 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
808 if test "$withval" != no
810 AC_DEFINE(Py_DEBUG, 1,
811 [Define if you want to build an interpreter with many run-time checks.])
814 else AC_MSG_RESULT(no); Py_DEBUG='false'
818 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
819 # merged with this chunk of code?
821 # Optimizer/debugger flags
822 # ------------------------
823 # (The following bit of code is complicated enough - please keep things
824 # indented properly. Just pretend you're editing Python code. ;-)
826 # There are two parallel sets of case statements below, one that checks to
827 # see if OPT was set and one that does BASECFLAGS setting based upon
828 # compiler and platform. BASECFLAGS tweaks need to be made even if the
831 # tweak OPT based on compiler and platform, only if the user didn't set
832 # it on the command line
838 if test "$CC" != 'g++' ; then
839 STRICT_PROTO="-Wstrict-prototypes"
841 # For gcc 4.x we need to use -fwrapv so lets check if its supported
842 if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
845 case $ac_cv_prog_cc_g in
847 if test "$Py_DEBUG" = 'true' ; then
848 # Optimization messes up debuggers, so turn it off for
850 OPT="-g -Wall $STRICT_PROTO"
852 OPT="-g $WRAP -O3 -Wall $STRICT_PROTO"
856 OPT="-O3 -Wall $STRICT_PROTO"
859 case $ac_sys_system in
860 SCO_SV*) OPT="$OPT -m486 -DSCO5"
870 # The current (beta) Monterey compiler dies with optimizations
871 # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
872 case $ac_sys_system in
882 # The -arch flags for universal builds on OSX
883 UNIVERSAL_ARCH_FLAGS=
884 AC_SUBST(UNIVERSAL_ARCH_FLAGS)
886 # tweak BASECFLAGS based on compiler and platform
889 # Python violates C99 rules, by casting between incompatible
890 # pointer types. GCC may generate bad code as a result of that,
891 # so use -fno-strict-aliasing if supported.
892 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
894 CC="$CC -fno-strict-aliasing"
895 AC_TRY_RUN([int main() { return 0; }],
896 ac_cv_no_strict_aliasing_ok=yes,
897 ac_cv_no_strict_aliasing_ok=no,
898 ac_cv_no_strict_aliasing_ok=no)
900 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
901 if test $ac_cv_no_strict_aliasing_ok = yes
903 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
906 # if using gcc on alpha, use -mieee to get (near) full IEEE 754
907 # support. Without this, treatment of subnormals doesn't follow
909 case $ac_sys_machine in
911 BASECFLAGS="$BASECFLAGS -mieee"
915 case $ac_sys_system in
917 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
919 # is there any other compiler on Darwin besides gcc?
921 # -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
922 # used to be here, but non-Apple gcc doesn't accept them.
925 if test "${enable_universalsdk}"; then
926 UNIVERSAL_ARCH_FLAGS=""
927 if test "$UNIVERSAL_ARCHS" = "32-bit" ; then
928 UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386"
931 elif test "$UNIVERSAL_ARCHS" = "64-bit" ; then
932 UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64"
934 elif test "$UNIVERSAL_ARCHS" = "all" ; then
935 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64"
936 ARCH_RUN_32BIT="arch -i386 -ppc"
939 AC_MSG_ERROR([proper usage is --with-universalarch=32-bit|64-bit|all])
944 BASECFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
945 tgt=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
946 if test "${UNIVERSALSDK}" != "/" -a "${tgt}" '>' '10.4' ; then
947 CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
951 # Calculate the right deployment target for this build.
953 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
954 if test ${cur_target} '>' 10.2; then
957 if test "${UNIVERSAL_ARCHS}" = "all"; then
958 # Ensure that the default platform for a 4-way
959 # universal build is OSX 10.5, that's the first
960 # OS release where 4-way builds make sense.
963 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
965 # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
966 # environment with a value that is the same as what we'll use
967 # in the Makefile to ensure that we'll get the same compiler
968 # environment during configure and build time.
969 MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
970 export MACOSX_DEPLOYMENT_TARGET
971 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
975 BASECFLAGS="$BASECFLAGS -mieee"
981 case $ac_sys_system in
983 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
986 BASECFLAGS="$BASECFLAGS -ieee -std"
989 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
995 if test "$Py_DEBUG" = 'true'; then
1001 if test "$ac_arch_flags"
1003 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
1006 # disable check for icc since it seems to pass, but generates a warning
1009 ac_cv_opt_olimit_ok=no
1012 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
1013 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
1015 CC="$CC -OPT:Olimit=0"
1016 AC_TRY_RUN([int main() { return 0; }],
1017 ac_cv_opt_olimit_ok=yes,
1018 ac_cv_opt_olimit_ok=no,
1019 ac_cv_opt_olimit_ok=no)
1021 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
1022 if test $ac_cv_opt_olimit_ok = yes; then
1023 case $ac_sys_system in
1024 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
1025 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
1030 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
1034 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
1035 AC_CACHE_VAL(ac_cv_olimit_ok,
1037 CC="$CC -Olimit 1500"
1038 AC_TRY_RUN([int main() { return 0; }],
1039 ac_cv_olimit_ok=yes,
1043 AC_MSG_RESULT($ac_cv_olimit_ok)
1044 if test $ac_cv_olimit_ok = yes; then
1045 BASECFLAGS="$BASECFLAGS -Olimit 1500"
1049 # Check whether GCC supports PyArg_ParseTuple format
1050 if test "$GCC" = "yes"
1052 AC_MSG_CHECKING(whether gcc supports ParseTuple __format__)
1054 CFLAGS="$CFLAGS -Werror"
1056 void f(char*,...)__attribute((format(PyArg_ParseTuple, 1, 2)));
1058 AC_DEFINE(HAVE_ATTRIBUTE_FORMAT_PARSETUPLE, 1, [Define if GCC supports __attribute__((format(PyArg_ParseTuple, 2, 3)))])
1065 # On some compilers, pthreads are available without further options
1066 # (e.g. MacOS X). On some of these systems, the compiler will not
1067 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
1068 # So we have to see first whether pthreads are available without
1069 # options before we can check whether -Kpthread improves anything.
1070 AC_MSG_CHECKING(whether pthreads are available without options)
1071 AC_CACHE_VAL(ac_cv_pthread_is_default,
1073 #include <pthread.h>
1075 void* routine(void* p){return NULL;}
1079 if(pthread_create(&p,NULL,routine,NULL)!=0)
1081 (void)pthread_detach(p);
1086 ac_cv_pthread_is_default=yes
1090 ac_cv_pthread_is_default=no,
1091 ac_cv_pthread_is_default=no)
1093 AC_MSG_RESULT($ac_cv_pthread_is_default)
1096 if test $ac_cv_pthread_is_default = yes
1100 # -Kpthread, if available, provides the right #defines
1101 # and linker options to make pthread_create available
1102 # Some compilers won't report that they do not support -Kpthread,
1103 # so we need to run a program to see whether it really made the
1104 # function available.
1105 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
1106 AC_CACHE_VAL(ac_cv_kpthread,
1110 #include <pthread.h>
1112 void* routine(void* p){return NULL;}
1116 if(pthread_create(&p,NULL,routine,NULL)!=0)
1118 (void)pthread_detach(p);
1126 AC_MSG_RESULT($ac_cv_kpthread)
1129 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
1131 # -Kthread, if available, provides the right #defines
1132 # and linker options to make pthread_create available
1133 # Some compilers won't report that they do not support -Kthread,
1134 # so we need to run a program to see whether it really made the
1135 # function available.
1136 AC_MSG_CHECKING(whether $CC accepts -Kthread)
1137 AC_CACHE_VAL(ac_cv_kthread,
1141 #include <pthread.h>
1143 void* routine(void* p){return NULL;}
1147 if(pthread_create(&p,NULL,routine,NULL)!=0)
1149 (void)pthread_detach(p);
1157 AC_MSG_RESULT($ac_cv_kthread)
1160 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
1162 # -pthread, if available, provides the right #defines
1163 # and linker options to make pthread_create available
1164 # Some compilers won't report that they do not support -pthread,
1165 # so we need to run a program to see whether it really made the
1166 # function available.
1167 AC_MSG_CHECKING(whether $CC accepts -pthread)
1168 AC_CACHE_VAL(ac_cv_thread,
1172 #include <pthread.h>
1174 void* routine(void* p){return NULL;}
1178 if(pthread_create(&p,NULL,routine,NULL)!=0)
1180 (void)pthread_detach(p);
1188 AC_MSG_RESULT($ac_cv_pthread)
1191 # If we have set a CC compiler flag for thread support then
1192 # check if it works for CXX, too.
1196 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1199 if test "$ac_cv_kpthread" = "yes"
1201 CXX="$CXX -Kpthread"
1202 ac_cv_cxx_thread=yes
1203 elif test "$ac_cv_kthread" = "yes"
1206 ac_cv_cxx_thread=yes
1207 elif test "$ac_cv_pthread" = "yes"
1210 ac_cv_cxx_thread=yes
1213 if test $ac_cv_cxx_thread = yes
1215 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1216 $CXX -c conftest.$ac_ext 2>&5
1217 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1218 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1220 ac_cv_cxx_thread=yes
1226 AC_MSG_RESULT($ac_cv_cxx_thread)
1230 dnl # check for ANSI or K&R ("traditional") preprocessor
1231 dnl AC_MSG_CHECKING(for C preprocessor type)
1232 dnl AC_TRY_COMPILE([
1233 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1235 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1236 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1237 dnl AC_MSG_RESULT($cpp_type)
1239 # checks for header files
1241 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1243 ieeefp.h io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
1244 shadow.h signal.h stdint.h stropts.h termios.h thread.h \
1246 sys/audioio.h sys/bsdtty.h sys/epoll.h sys/event.h sys/file.h sys/loadavg.h \
1247 sys/lock.h sys/mkdev.h sys/modem.h \
1248 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1249 sys/termio.h sys/time.h \
1250 sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1251 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1252 bluetooth/bluetooth.h linux/tipc.h)
1256 # On Solaris, term.h requires curses.h
1257 AC_CHECK_HEADERS(term.h,,,[
1258 #ifdef HAVE_CURSES_H
1263 # On Linux, netlink.h requires asm/types.h
1264 AC_CHECK_HEADERS(linux/netlink.h,,,[
1265 #ifdef HAVE_ASM_TYPES_H
1266 #include <asm/types.h>
1268 #ifdef HAVE_SYS_SOCKET_H
1269 #include <sys/socket.h>
1273 # checks for typedefs
1275 AC_MSG_CHECKING(for clock_t in time.h)
1276 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1277 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1279 AC_MSG_RESULT($was_it_defined)
1281 # Check whether using makedev requires defining _OSF_SOURCE
1282 AC_MSG_CHECKING(for makedev)
1283 AC_TRY_LINK([#include <sys/types.h> ],
1285 ac_cv_has_makedev=yes,
1286 ac_cv_has_makedev=no)
1287 if test "$ac_cv_has_makedev" = "no"; then
1288 # we didn't link, try if _OSF_SOURCE will allow us to link
1290 #define _OSF_SOURCE 1
1291 #include <sys/types.h>
1294 ac_cv_has_makedev=yes,
1295 ac_cv_has_makedev=no)
1296 if test "$ac_cv_has_makedev" = "yes"; then
1297 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1300 AC_MSG_RESULT($ac_cv_has_makedev)
1301 if test "$ac_cv_has_makedev" = "yes"; then
1302 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1305 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1306 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1307 # defined, but the compiler does not support pragma redefine_extname,
1308 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1309 # structures (such as rlimit64) without declaring them. As a
1310 # work-around, disable LFS on such configurations
1313 AC_MSG_CHECKING(Solaris LFS bug)
1315 #define _LARGEFILE_SOURCE 1
1316 #define _FILE_OFFSET_BITS 64
1317 #include <sys/resource.h>
1318 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1319 AC_MSG_RESULT($sol_lfs_bug)
1320 if test "$sol_lfs_bug" = "yes"; then
1324 if test "$use_lfs" = "yes"; then
1325 # Two defines needed to enable largefile support on various platforms
1326 # These may affect some typedefs
1327 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1328 [This must be defined on some systems to enable large file support.])
1329 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1330 [This must be set to 64 on some systems to enable large file support.])
1333 # Add some code to confdefs.h so that the test for off_t works on SCO
1334 cat >> confdefs.h <<\EOF
1340 # Type availability checks
1351 AC_CHECK_TYPE(ssize_t,
1352 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1354 # Sizes of various common basic types
1355 # ANSI C requires sizeof(char) == 1, so no need to check it
1356 AC_CHECK_SIZEOF(int, 4)
1357 AC_CHECK_SIZEOF(long, 4)
1358 AC_CHECK_SIZEOF(void *, 4)
1359 AC_CHECK_SIZEOF(short, 2)
1360 AC_CHECK_SIZEOF(float, 4)
1361 AC_CHECK_SIZEOF(double, 8)
1362 AC_CHECK_SIZEOF(fpos_t, 4)
1363 AC_CHECK_SIZEOF(size_t, 4)
1364 AC_CHECK_SIZEOF(pid_t, 4)
1366 AC_MSG_CHECKING(for long long support)
1368 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1369 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1372 AC_MSG_RESULT($have_long_long)
1373 if test "$have_long_long" = yes ; then
1374 AC_CHECK_SIZEOF(long long, 8)
1377 AC_MSG_CHECKING(for long double support)
1379 AC_TRY_COMPILE([], [long double x; x = (long double)0.;], [
1380 AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define this if you have the type long double.])
1381 have_long_double=yes
1383 AC_MSG_RESULT($have_long_double)
1384 if test "$have_long_double" = yes ; then
1385 AC_CHECK_SIZEOF(long double, 12)
1388 AC_MSG_CHECKING(for _Bool support)
1390 AC_TRY_COMPILE([], [_Bool x; x = (_Bool)0;], [
1391 AC_DEFINE(HAVE_C99_BOOL, 1, [Define this if you have the type _Bool.])
1394 AC_MSG_RESULT($have_c99_bool)
1395 if test "$have_c99_bool" = yes ; then
1396 AC_CHECK_SIZEOF(_Bool, 1)
1399 AC_CHECK_TYPES(uintptr_t,
1400 [AC_CHECK_SIZEOF(uintptr_t, 4)],
1401 [], [#ifdef HAVE_STDINT_H
1406 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1407 AC_MSG_CHECKING(size of off_t)
1408 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1409 [AC_TRY_RUN([#include <stdio.h>
1410 #include <sys/types.h>
1413 FILE *f=fopen("conftestval", "w");
1415 fprintf(f, "%d\n", sizeof(off_t));
1418 ac_cv_sizeof_off_t=`cat conftestval`,
1419 ac_cv_sizeof_off_t=0,
1420 ac_cv_sizeof_off_t=4)
1422 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1423 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1424 [The number of bytes in an off_t.])
1426 AC_MSG_CHECKING(whether to enable large file support)
1427 if test "$have_long_long" = yes -a \
1428 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1429 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1430 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1431 [Defined to enable large file support when an off_t is bigger than a long
1432 and long long is available and at least as big as an off_t. You may need
1433 to add some flags for configuration and compilation to enable this mode.
1434 (For Solaris and Linux, the necessary defines are already defined.)])
1440 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1441 AC_MSG_CHECKING(size of time_t)
1442 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1443 [AC_TRY_RUN([#include <stdio.h>
1447 FILE *f=fopen("conftestval", "w");
1449 fprintf(f, "%d\n", sizeof(time_t));
1452 ac_cv_sizeof_time_t=`cat conftestval`,
1453 ac_cv_sizeof_time_t=0,
1454 ac_cv_sizeof_time_t=4)
1456 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1457 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1458 [The number of bytes in a time_t.])
1461 # if have pthread_t then define SIZEOF_PTHREAD_T
1463 if test "$ac_cv_kpthread" = "yes"
1464 then CC="$CC -Kpthread"
1465 elif test "$ac_cv_kthread" = "yes"
1466 then CC="$CC -Kthread"
1467 elif test "$ac_cv_pthread" = "yes"
1468 then CC="$CC -pthread"
1470 AC_MSG_CHECKING(for pthread_t)
1472 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1473 AC_MSG_RESULT($have_pthread_t)
1474 if test "$have_pthread_t" = yes ; then
1475 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1476 AC_MSG_CHECKING(size of pthread_t)
1477 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1478 [AC_TRY_RUN([#include <stdio.h>
1479 #include <pthread.h>
1482 FILE *f=fopen("conftestval", "w");
1484 fprintf(f, "%d\n", sizeof(pthread_t));
1487 ac_cv_sizeof_pthread_t=`cat conftestval`,
1488 ac_cv_sizeof_pthread_t=0,
1489 ac_cv_sizeof_pthread_t=4)
1491 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1492 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1493 [The number of bytes in a pthread_t.])
1497 AC_MSG_CHECKING(for --enable-toolbox-glue)
1498 AC_ARG_ENABLE(toolbox-glue,
1499 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1501 if test -z "$enable_toolbox_glue"
1503 case $ac_sys_system/$ac_sys_release in
1505 enable_toolbox_glue="yes";;
1507 enable_toolbox_glue="no";;
1510 case "$enable_toolbox_glue" in
1512 extra_machdep_objs="Python/mactoolboxglue.o"
1513 extra_undefs="-u _PyMac_Error"
1514 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1515 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1518 extra_machdep_objs=""
1522 AC_MSG_RESULT($enable_toolbox_glue)
1525 AC_SUBST(OTHER_LIBTOOL_OPT)
1526 case $ac_sys_system/$ac_sys_release in
1527 Darwin/@<:@01567@:>@\..*)
1528 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1531 OTHER_LIBTOOL_OPT=""
1535 AC_SUBST(LIBTOOL_CRUFT)
1536 case $ac_sys_system/$ac_sys_release in
1537 Darwin/@<:@01567@:>@\..*)
1538 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1539 if test "${enable_universalsdk}"; then
1542 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1544 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1545 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1547 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1548 if test ${gcc_version} '<' 4.0
1550 LIBTOOL_CRUFT="-lcc_dynamic"
1554 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1555 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1556 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1559 AC_MSG_CHECKING(for --enable-framework)
1560 if test "$enable_framework"
1562 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1563 # -F. is needed to allow linking to the framework while
1564 # in the build location.
1565 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1566 [Define if you want to produce an OpenStep/Rhapsody framework
1567 (shared library plus accessory files).])
1573 AC_MSG_CHECKING(for dyld)
1574 case $ac_sys_system/$ac_sys_release in
1576 AC_DEFINE(WITH_DYLD, 1,
1577 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1578 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1579 linker (rld). Dyld is necessary to support frameworks.])
1580 AC_MSG_RESULT(always on for Darwin)
1587 # Set info about shared libraries.
1592 AC_SUBST(LINKFORSHARED)
1593 # SO is the extension of shared libraries `(including the dot!)
1594 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1598 case $ac_sys_system in
1609 # this might also be a termcap variable, see #610332
1611 echo '====================================================================='
1613 echo '+ WARNING: You have set SO in your environment. +'
1614 echo '+ Do you really mean to change the extension for shared libraries? +'
1615 echo '+ Continuing in 10 seconds to let you to ponder. +'
1617 echo '====================================================================='
1622 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1623 # LDSHARED is the ld *command* used to create shared library
1624 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1625 # (Shared libraries in this instance are shared modules to be loaded into
1626 # Python, as opposed to building Python itself as a shared library.)
1627 AC_MSG_CHECKING(LDSHARED)
1628 if test -z "$LDSHARED"
1630 case $ac_sys_system/$ac_sys_release in
1632 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1633 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1636 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1637 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1639 IRIX/5*) LDSHARED="ld -shared";;
1640 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1642 if test "$GCC" = "yes"
1643 then LDSHARED='$(CC) -shared'
1644 else LDSHARED='$(CC) -G';
1647 if test "$GCC" = "yes"
1648 then LDSHARED='$(CC) -shared'
1649 else LDSHARED='ld -b';
1651 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1653 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1654 if test "$enable_framework" ; then
1655 # Link against the framework. All externals should be defined.
1656 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1657 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1659 # No framework. Ignore undefined symbols, assuming they come from Python
1660 LDSHARED="$LDSHARED -undefined suppress"
1662 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1663 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1664 if test "$enable_framework" ; then
1665 # Link against the framework. All externals should be defined.
1666 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1667 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1669 # No framework, use the Python app as bundle-loader
1670 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1671 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1674 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1675 # This allows an extension to be used in any Python
1677 if test ${MACOSX_DEPLOYMENT_TARGET} '>' 10.2
1679 if test "${enable_universalsdk}"; then
1680 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1682 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1683 BLDSHARED="$LDSHARED"
1685 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1686 if test "$enable_framework" ; then
1687 # Link against the framework. All externals should be defined.
1688 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1689 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1691 # No framework, use the Python app as bundle-loader
1692 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1693 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1697 Linux*|GNU*|QNX*) LDSHARED='$(CC) -shared';;
1698 BSD/OS*/4*) LDSHARED="gcc -shared";;
1700 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1702 LDSHARED="$CC -shared ${LDFLAGS}"
1704 LDSHARED="ld -Bshareable ${LDFLAGS}"
1707 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1709 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1712 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1713 LDSHARED="ld -Bshareable ${LDFLAGS}"
1716 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1720 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1721 OpenUNIX*|UnixWare*)
1722 if test "$GCC" = "yes"
1723 then LDSHARED='$(CC) -shared'
1724 else LDSHARED='$(CC) -G'
1726 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1727 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1728 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1729 atheos*) LDSHARED="gcc -shared";;
1733 AC_MSG_RESULT($LDSHARED)
1734 BLDSHARED=${BLDSHARED-$LDSHARED}
1735 # CCSHARED are the C *flags* used to create objects to go into a shared
1736 # library (module) -- this is only needed for a few systems
1737 AC_MSG_CHECKING(CCSHARED)
1738 if test -z "$CCSHARED"
1740 case $ac_sys_system/$ac_sys_release in
1741 SunOS*) if test "$GCC" = yes;
1742 then CCSHARED="-fPIC";
1743 elif test `uname -p` = sparc;
1744 then CCSHARED="-xcode=pic32";
1745 else CCSHARED="-Kpic";
1747 hp*|HP*) if test "$GCC" = yes;
1748 then CCSHARED="-fPIC";
1751 Linux*|GNU*) CCSHARED="-fPIC";;
1752 BSD/OS*/4*) CCSHARED="-fpic";;
1753 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1754 OpenUNIX*|UnixWare*)
1755 if test "$GCC" = "yes"
1756 then CCSHARED="-fPIC"
1757 else CCSHARED="-KPIC"
1760 if test "$GCC" = "yes"
1761 then CCSHARED="-fPIC"
1762 else CCSHARED="-Kpic -belf"
1764 Monterey*) CCSHARED="-G";;
1765 IRIX*/6*) case $CC in
1766 *gcc*) CCSHARED="-shared";;
1769 atheos*) CCSHARED="-fPIC";;
1772 AC_MSG_RESULT($CCSHARED)
1773 # LINKFORSHARED are the flags passed to the $(CC) command that links
1774 # the python executable -- this is only needed for a few systems
1775 AC_MSG_CHECKING(LINKFORSHARED)
1776 if test -z "$LINKFORSHARED"
1778 case $ac_sys_system/$ac_sys_release in
1779 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1781 LINKFORSHARED="-Wl,-E -Wl,+s";;
1782 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1783 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1784 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1785 # -u libsys_s pulls in all symbols in libsys
1787 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1789 # not used by the core itself but which needs to be in the core so
1790 # that dynamically loaded extension modules have access to it.
1791 # -prebind is no longer used, because it actually seems to give a
1792 # slowdown in stead of a speedup, maybe due to the large number of
1793 # dynamic loads Python does.
1795 LINKFORSHARED="$extra_undefs"
1796 if test "$enable_framework"
1798 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1800 LINKFORSHARED="$LINKFORSHARED";;
1801 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1802 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1803 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1804 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1805 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1807 LINKFORSHARED="-Wl,--export-dynamic"
1809 SunOS/5*) case $CC in
1811 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1813 LINKFORSHARED="-Xlinker --export-dynamic"
1817 if test $enable_shared = "no"
1819 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1822 # -Wl,-E causes the symbols to be added to the dynamic
1823 # symbol table so that they can be found when a module
1824 # is loaded. -N 2048K causes the stack size to be set
1825 # to 2048 kilobytes so that the stack doesn't overflow
1826 # when running test_compile.py.
1827 LINKFORSHARED='-Wl,-E -N 2048K';;
1830 AC_MSG_RESULT($LINKFORSHARED)
1833 AC_SUBST(CFLAGSFORSHARED)
1834 AC_MSG_CHECKING(CFLAGSFORSHARED)
1835 if test ! "$LIBRARY" = "$LDLIBRARY"
1837 case $ac_sys_system in
1839 # Cygwin needs CCSHARED when building extension DLLs
1840 # but not when building the interpreter DLL.
1841 CFLAGSFORSHARED='';;
1843 CFLAGSFORSHARED='$(CCSHARED)'
1846 AC_MSG_RESULT($CFLAGSFORSHARED)
1848 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1849 # library (with --enable-shared).
1850 # For platforms on which shared libraries are not allowed to have unresolved
1851 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1852 # if it is not required, since it creates a dependency of the shared library
1853 # to LIBS. This, in turn, means that applications linking the shared libpython
1854 # don't need to link LIBS explicitly. The default should be only changed
1855 # on systems where this approach causes problems.
1857 AC_MSG_CHECKING(SHLIBS)
1858 case "$ac_sys_system" in
1862 AC_MSG_RESULT($SHLIBS)
1865 # checks for libraries
1866 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1867 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1869 # only check for sem_init if thread support is requested
1870 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1871 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1872 # posix4 on Solaris 2.6
1873 # pthread (first!) on Linux
1876 # check if we need libintl for locale functions
1877 AC_CHECK_LIB(intl, textdomain,
1878 AC_DEFINE(WITH_LIBINTL, 1,
1879 [Define to 1 if libintl is needed for locale functions.]))
1881 # checks for system dependent C++ extensions support
1882 case "$ac_sys_system" in
1883 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1884 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1885 [loadAndInit("", 0, "")],
1886 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1887 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1888 and you want support for AIX C++ shared extension modules.])
1889 AC_MSG_RESULT(yes)],
1890 [AC_MSG_RESULT(no)]);;
1894 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1895 # BeOS' sockets are stashed in libnet.
1896 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1897 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1899 case "$ac_sys_system" in
1901 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1905 AC_MSG_CHECKING(for --with-libs)
1907 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1909 AC_MSG_RESULT($withval)
1910 LIBS="$withval $LIBS"
1912 [AC_MSG_RESULT(no)])
1914 # Check for use of the system libffi library
1915 AC_MSG_CHECKING(for --with-system-ffi)
1916 AC_ARG_WITH(system_ffi,
1917 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1919 AC_MSG_RESULT($with_system_ffi)
1921 # Check for --with-dbmliborder
1922 AC_MSG_CHECKING(for --with-dbmliborder)
1923 AC_ARG_WITH(dbmliborder,
1924 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'.]),
1926 if test x$with_dbmliborder = xyes
1928 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
1930 for db in `echo $with_dbmliborder | sed 's/:/ /g'`; do
1931 if test x$db != xndbm && test x$db != xgdbm && test x$db != xbdb
1933 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
1937 AC_MSG_RESULT($with_dbmliborder)
1939 # Determine if signalmodule should be used.
1940 AC_SUBST(USE_SIGNAL_MODULE)
1941 AC_SUBST(SIGNAL_OBJS)
1942 AC_MSG_CHECKING(for --with-signal-module)
1943 AC_ARG_WITH(signal-module,
1944 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1946 if test -z "$with_signal_module"
1947 then with_signal_module="yes"
1949 AC_MSG_RESULT($with_signal_module)
1951 if test "${with_signal_module}" = "yes"; then
1952 USE_SIGNAL_MODULE=""
1955 USE_SIGNAL_MODULE="#"
1956 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1959 # This is used to generate Setup.config
1960 AC_SUBST(USE_THREAD_MODULE)
1961 USE_THREAD_MODULE=""
1963 AC_MSG_CHECKING(for --with-dec-threads)
1965 AC_ARG_WITH(dec-threads,
1966 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1968 AC_MSG_RESULT($withval)
1970 if test "${with_thread+set}" != set; then
1971 with_thread="$withval";
1973 [AC_MSG_RESULT(no)])
1975 # Templates for things AC_DEFINEd more than once.
1976 # For a single AC_DEFINE, no template is needed.
1977 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1978 AH_TEMPLATE(_REENTRANT,
1979 [Define to force use of thread-safe errno, h_errno, and other functions])
1980 AH_TEMPLATE(WITH_THREAD,
1981 [Define if you want to compile in rudimentary thread support])
1983 AC_MSG_CHECKING(for --with-threads)
1984 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1985 AC_ARG_WITH(threads,
1986 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1988 # --with-thread is deprecated, but check for it anyway
1989 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1991 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1992 [with_threads=$with_thread])
1994 if test -z "$with_threads"
1995 then with_threads="yes"
1997 AC_MSG_RESULT($with_threads)
2000 if test "$with_threads" = "no"
2002 USE_THREAD_MODULE="#"
2003 elif test "$ac_cv_pthread_is_default" = yes
2005 AC_DEFINE(WITH_THREAD)
2006 # Defining _REENTRANT on system with POSIX threads should not hurt.
2007 AC_DEFINE(_REENTRANT)
2009 THREADOBJ="Python/thread.o"
2010 elif test "$ac_cv_kpthread" = "yes"
2013 if test "$ac_cv_cxx_thread" = "yes"; then
2014 CXX="$CXX -Kpthread"
2016 AC_DEFINE(WITH_THREAD)
2018 THREADOBJ="Python/thread.o"
2019 elif test "$ac_cv_kthread" = "yes"
2022 if test "$ac_cv_cxx_thread" = "yes"; then
2025 AC_DEFINE(WITH_THREAD)
2027 THREADOBJ="Python/thread.o"
2028 elif test "$ac_cv_pthread" = "yes"
2031 if test "$ac_cv_cxx_thread" = "yes"; then
2034 AC_DEFINE(WITH_THREAD)
2036 THREADOBJ="Python/thread.o"
2038 if test ! -z "$with_threads" -a -d "$with_threads"
2039 then LDFLAGS="$LDFLAGS -L$with_threads"
2041 if test ! -z "$withval" -a -d "$withval"
2042 then LDFLAGS="$LDFLAGS -L$withval"
2045 # According to the POSIX spec, a pthreads implementation must
2046 # define _POSIX_THREADS in unistd.h. Some apparently don't
2047 # (e.g. gnu pth with pthread emulation)
2048 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
2052 #ifdef _POSIX_THREADS
2055 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
2056 AC_MSG_RESULT($unistd_defines_pthreads)
2058 AC_DEFINE(_REENTRANT)
2059 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
2060 AC_DEFINE(C_THREADS)
2061 AC_DEFINE(HURD_C_THREADS, 1,
2062 [Define if you are using Mach cthreads directly under /include])
2063 LIBS="$LIBS -lthreads"
2064 THREADOBJ="Python/thread.o"],[
2065 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
2066 AC_DEFINE(C_THREADS)
2067 AC_DEFINE(MACH_C_THREADS, 1,
2068 [Define if you are using Mach cthreads under mach /])
2069 THREADOBJ="Python/thread.o"],[
2070 AC_MSG_CHECKING(for --with-pth)
2072 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
2073 [AC_MSG_RESULT($withval)
2074 AC_DEFINE([WITH_THREAD])
2075 AC_DEFINE([HAVE_PTH], 1,
2076 [Define if you have GNU PTH threads.])
2078 THREADOBJ="Python/thread.o"],
2081 # Just looking for pthread_create in libpthread is not enough:
2082 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
2083 # So we really have to include pthread.h, and then link.
2085 LIBS="$LIBS -lpthread"
2086 AC_MSG_CHECKING([for pthread_create in -lpthread])
2087 AC_TRY_LINK([#include <pthread.h>
2089 void * start_routine (void *arg) { exit (0); }], [
2090 pthread_create (NULL, NULL, start_routine, NULL)], [
2092 AC_DEFINE(WITH_THREAD)
2094 THREADOBJ="Python/thread.o"],[
2096 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
2098 THREADOBJ="Python/thread.o"],[
2099 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
2100 AC_DEFINE(ATHEOS_THREADS, 1,
2101 [Define this if you have AtheOS threads.])
2102 THREADOBJ="Python/thread.o"],[
2103 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
2104 AC_DEFINE(BEOS_THREADS, 1,
2105 [Define this if you have BeOS threads.])
2106 THREADOBJ="Python/thread.o"],[
2107 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
2109 LIBS="$LIBS -lpthreads"
2110 THREADOBJ="Python/thread.o"], [
2111 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
2114 THREADOBJ="Python/thread.o"], [
2115 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
2117 LIBS="$LIBS -lpthread"
2118 THREADOBJ="Python/thread.o"], [
2119 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
2122 THREADOBJ="Python/thread.o"],[
2123 USE_THREAD_MODULE="#"])
2124 ])])])])])])])])])])
2126 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
2128 THREADOBJ="Python/thread.o"
2129 USE_THREAD_MODULE=""])
2131 if test "$posix_threads" != "yes"; then
2132 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
2133 LIBS="$LIBS -lthread"
2134 THREADOBJ="Python/thread.o"
2135 USE_THREAD_MODULE=""])
2138 if test "$USE_THREAD_MODULE" != "#"
2140 # If the above checks didn't disable threads, (at least) OSF1
2141 # needs this '-threads' argument during linking.
2142 case $ac_sys_system in
2143 OSF1) LDLAST=-threads;;
2148 if test "$posix_threads" = "yes"; then
2149 if test "$unistd_defines_pthreads" = "no"; then
2150 AC_DEFINE(_POSIX_THREADS, 1,
2151 [Define if you have POSIX threads,
2152 and your system does not define that.])
2155 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
2156 case $ac_sys_system/$ac_sys_release in
2157 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
2158 Defined for Solaris 2.6 bug in pthread header.)
2160 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2161 Define if the Posix semaphores do not work on your system)
2163 AIX/5) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2164 Define if the Posix semaphores do not work on your system)
2168 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
2169 AC_CACHE_VAL(ac_cv_pthread_system_supported,
2170 [AC_TRY_RUN([#include <pthread.h>
2171 void *foo(void *parm) {
2175 pthread_attr_t attr;
2177 if (pthread_attr_init(&attr)) exit(-1);
2178 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
2179 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
2182 ac_cv_pthread_system_supported=yes,
2183 ac_cv_pthread_system_supported=no,
2184 ac_cv_pthread_system_supported=no)
2186 AC_MSG_RESULT($ac_cv_pthread_system_supported)
2187 if test "$ac_cv_pthread_system_supported" = "yes"; then
2188 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2190 AC_CHECK_FUNCS(pthread_sigmask,
2191 [case $ac_sys_system in
2193 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2194 [Define if pthread_sigmask() does not work on your system.])
2200 # Check for enable-ipv6
2201 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2202 AC_MSG_CHECKING([if --enable-ipv6 is specified])
2204 [ --enable-ipv6 Enable ipv6 (with ipv4) support
2205 --disable-ipv6 Disable ipv6 support],
2206 [ case "$enableval" in
2211 *) AC_MSG_RESULT(yes)
2212 AC_DEFINE(ENABLE_IPV6)
2218 dnl the check does not work on cross compilation case...
2219 AC_TRY_RUN([ /* AF_INET6 available check */
2220 #include <sys/types.h>
2221 #include <sys/socket.h>
2224 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2238 if test "$ipv6" = "yes"; then
2239 AC_MSG_CHECKING(if RFC2553 API is available)
2240 AC_TRY_COMPILE([#include <sys/types.h>
2241 #include <netinet/in.h>],
2242 [struct sockaddr_in6 x;
2246 AC_MSG_RESULT(no, IPv6 disabled)
2250 if test "$ipv6" = "yes"; then
2251 AC_DEFINE(ENABLE_IPV6)
2259 if test "$ipv6" = "yes"; then
2260 AC_MSG_CHECKING([ipv6 stack type])
2261 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2265 dnl http://www.kame.net/
2267 #include <netinet/in.h>
2268 #ifdef IPV6_INRIA_VERSION
2274 dnl http://www.kame.net/
2276 #include <netinet/in.h>
2282 ipv6libdir=/usr/local/v6/lib
2286 dnl http://www.v6.linux.or.jp/
2288 #include <features.h>
2289 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2296 dnl http://www.v6.linux.or.jp/
2297 if test -d /usr/inet6; then
2300 ipv6libdir=/usr/inet6/lib
2301 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2305 if test -f /etc/netconfig; then
2306 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2314 #include <sys/param.h>
2315 #ifdef _TOSHIBA_INET6
2320 ipv6libdir=/usr/local/v6/lib])
2324 #include </usr/local/v6/include/sys/v6config.h>
2330 ipv6libdir=/usr/local/v6/lib;
2331 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2335 #include <sys/param.h>
2336 #ifdef _ZETA_MINAMI_INET6
2341 ipv6libdir=/usr/local/v6/lib])
2344 if test "$ipv6type" != "unknown"; then
2348 AC_MSG_RESULT($ipv6type)
2351 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2352 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2353 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2354 echo "using lib$ipv6lib"
2356 if test $ipv6trylibc = "yes"; then
2359 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2360 echo "You need to fetch lib$ipv6lib.a from appropriate"
2361 echo 'ipv6 kit and compile beforehand.'
2367 AC_MSG_CHECKING(for OSX 10.5 SDK or later)
2368 AC_TRY_COMPILE([#include <Carbon/Carbon.h>], FSIORefNum fRef = 0,
2369 AC_DEFINE(HAVE_OSX105_SDK, 1, Define if compiling using MacOS X 10.5 SDK or later.)
2374 # Check for --with-doc-strings
2375 AC_MSG_CHECKING(for --with-doc-strings)
2376 AC_ARG_WITH(doc-strings,
2377 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2379 if test -z "$with_doc_strings"
2380 then with_doc_strings="yes"
2382 if test "$with_doc_strings" != "no"
2384 AC_DEFINE(WITH_DOC_STRINGS, 1,
2385 [Define if you want documentation strings in extension modules])
2387 AC_MSG_RESULT($with_doc_strings)
2389 # Check for Python-specific malloc support
2390 AC_MSG_CHECKING(for --with-tsc)
2392 [ --with(out)-tsc enable/disable timestamp counter profile], [
2393 if test "$withval" != no
2395 AC_DEFINE(WITH_TSC, 1,
2396 [Define to profile with the Pentium timestamp counter])
2398 else AC_MSG_RESULT(no)
2400 [AC_MSG_RESULT(no)])
2402 # Check for Python-specific malloc support
2403 AC_MSG_CHECKING(for --with-pymalloc)
2404 AC_ARG_WITH(pymalloc,
2405 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2407 if test -z "$with_pymalloc"
2408 then with_pymalloc="yes"
2410 if test "$with_pymalloc" != "no"
2412 AC_DEFINE(WITH_PYMALLOC, 1,
2413 [Define if you want to compile in Python-specific mallocs])
2415 AC_MSG_RESULT($with_pymalloc)
2417 # Check for --with-wctype-functions
2418 AC_MSG_CHECKING(for --with-wctype-functions)
2419 AC_ARG_WITH(wctype-functions,
2420 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2422 if test "$withval" != no
2424 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2425 [Define if you want wctype.h functions to be used instead of the
2426 one supplied by Python itself. (see Include/unicodectype.h).])
2428 else AC_MSG_RESULT(no)
2430 [AC_MSG_RESULT(no)])
2432 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2436 # the dlopen() function means we might want to use dynload_shlib.o. some
2437 # platforms, such as AIX, have dlopen(), but don't want to use it.
2438 AC_CHECK_FUNCS(dlopen)
2440 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2441 # loading of modules.
2442 AC_SUBST(DYNLOADFILE)
2443 AC_MSG_CHECKING(DYNLOADFILE)
2444 if test -z "$DYNLOADFILE"
2446 case $ac_sys_system/$ac_sys_release in
2447 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2448 if test "$ac_cv_func_dlopen" = yes
2449 then DYNLOADFILE="dynload_shlib.o"
2450 else DYNLOADFILE="dynload_aix.o"
2453 BeOS*) DYNLOADFILE="dynload_beos.o";;
2454 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2455 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2456 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2457 atheos*) DYNLOADFILE="dynload_atheos.o";;
2459 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2460 # out any dynamic loading
2461 if test "$ac_cv_func_dlopen" = yes
2462 then DYNLOADFILE="dynload_shlib.o"
2463 else DYNLOADFILE="dynload_stub.o"
2468 AC_MSG_RESULT($DYNLOADFILE)
2469 if test "$DYNLOADFILE" != "dynload_stub.o"
2471 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2472 [Defined when any dynamic module loading is enabled.])
2475 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2477 AC_SUBST(MACHDEP_OBJS)
2478 AC_MSG_CHECKING(MACHDEP_OBJS)
2479 if test -z "$MACHDEP_OBJS"
2481 MACHDEP_OBJS=$extra_machdep_objs
2483 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2485 AC_MSG_RESULT(MACHDEP_OBJS)
2487 # checks for library functions
2488 AC_CHECK_FUNCS(alarm setitimer getitimer bind_textdomain_codeset chown \
2489 clock confstr ctermid execv fchmod fchown fork fpathconf ftime ftruncate \
2490 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2491 getpriority getpwent getspnam getspent getsid getwd \
2492 kill killpg lchmod lchown lstat mkfifo mknod mktime \
2493 mremap nice pathconf pause plock poll pthread_init \
2494 putenv readlink realpath \
2495 select sem_open sem_timedwait sem_getvalue sem_unlink setegid seteuid \
2497 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2498 sigaction siginterrupt sigrelse strftime \
2499 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2500 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2502 # For some functions, having a definition is not sufficient, since
2503 # we want to take their address.
2504 AC_MSG_CHECKING(for chroot)
2505 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2506 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2510 AC_MSG_CHECKING(for link)
2511 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2512 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2516 AC_MSG_CHECKING(for symlink)
2517 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2518 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2522 AC_MSG_CHECKING(for fchdir)
2523 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2524 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2528 AC_MSG_CHECKING(for fsync)
2529 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2530 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2534 AC_MSG_CHECKING(for fdatasync)
2535 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2536 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2540 AC_MSG_CHECKING(for epoll)
2541 AC_TRY_COMPILE([#include <sys/epoll.h>], void *x=epoll_create,
2542 AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
2546 AC_MSG_CHECKING(for kqueue)
2548 #include <sys/types.h>
2549 #include <sys/event.h>
2551 AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
2555 # On some systems (eg. FreeBSD 5), we would find a definition of the
2556 # functions ctermid_r, setgroups in the library, but no prototype
2557 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2558 # address to avoid compiler warnings and potential miscompilations
2559 # because of the missing prototypes.
2561 AC_MSG_CHECKING(for ctermid_r)
2563 #include "confdefs.h"
2565 ], void* p = ctermid_r,
2566 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2571 AC_MSG_CHECKING(for flock)
2573 #include "confdefs.h"
2574 #include <sys/file.h>
2576 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2581 AC_MSG_CHECKING(for getpagesize)
2583 #include "confdefs.h"
2585 ], void* p = getpagesize,
2586 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2592 AC_CHECK_PROGS(TRUE, true, /bin/true)
2594 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2595 dnl On others, they are in the C library, so we to take no action
2596 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2597 AC_CHECK_LIB(resolv, inet_aton)
2600 # On Tru64, chflags seems to be present, but calling it will
2602 AC_MSG_CHECKING(for chflags)
2604 #include <sys/stat.h>
2606 int main(int argc, char*argv[])
2608 if(chflags(argv[0], 0) != 0)
2612 ],AC_DEFINE(HAVE_CHFLAGS, 1, Define to 1 if you have the `chflags' function.)
2617 AC_MSG_CHECKING(for lchflags)
2619 #include <sys/stat.h>
2621 int main(int argc, char*argv[])
2623 if(lchflags(argv[0], 0) != 0)
2627 ],AC_DEFINE(HAVE_LCHFLAGS, 1, Define to 1 if you have the `lchflags' function.)
2632 dnl Check if system zlib has *Copy() functions
2634 dnl On MacOSX the linker will search for dylibs on the entire linker path
2635 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2636 dnl to revert to a more traditional unix behaviour and make it possible to
2637 dnl override the system libz with a local static library of libz. Temporarily
2638 dnl add that flag to our CFLAGS as well to ensure that we check the version
2639 dnl of libz that will be used by setup.py.
2640 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2641 dnl environment as setup.py (and leaving it out can cause configure to use the
2642 dnl wrong version of the library)
2643 case $ac_sys_system/$ac_sys_release in
2645 _CUR_CFLAGS="${CFLAGS}"
2646 _CUR_LDFLAGS="${LDFLAGS}"
2647 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2648 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2652 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2654 case $ac_sys_system/$ac_sys_release in
2656 CFLAGS="${_CUR_CFLAGS}"
2657 LDFLAGS="${_CUR_LDFLAGS}"
2661 AC_MSG_CHECKING(for hstrerror)
2663 #include "confdefs.h"
2665 ], void* p = hstrerror; hstrerror(0),
2666 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2671 AC_MSG_CHECKING(for inet_aton)
2673 #include "confdefs.h"
2674 #include <sys/types.h>
2675 #include <sys/socket.h>
2676 #include <netinet/in.h>
2677 #include <arpa/inet.h>
2678 ], void* p = inet_aton;inet_aton(0,0),
2679 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2684 AC_MSG_CHECKING(for inet_pton)
2686 #include "confdefs.h"
2687 #include <sys/types.h>
2688 #include <sys/socket.h>
2689 #include <netinet/in.h>
2690 #include <arpa/inet.h>
2691 ], void* p = inet_pton,
2692 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2697 # On some systems, setgroups is in unistd.h, on others, in grp.h
2698 AC_MSG_CHECKING(for setgroups)
2700 #include "confdefs.h"
2706 void* p = setgroups,
2707 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2712 # check for openpty and forkpty
2714 AC_CHECK_FUNCS(openpty,,
2715 AC_CHECK_LIB(util,openpty,
2716 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2717 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2720 AC_CHECK_FUNCS(forkpty,,
2721 AC_CHECK_LIB(util,forkpty,
2722 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2723 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2728 AC_CHECK_FUNCS(memmove)
2730 # check for long file support functions
2731 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2733 AC_REPLACE_FUNCS(dup2 getcwd strdup)
2734 AC_CHECK_FUNCS(getpgrp,
2735 AC_TRY_COMPILE([#include <unistd.h>],
2737 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2738 [Define if getpgrp() must be called as getpgrp(0).])
2741 AC_CHECK_FUNCS(setpgrp,
2742 AC_TRY_COMPILE([#include <unistd.h>],
2744 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2745 [Define if setpgrp() must be called as setpgrp(0, 0).])
2748 AC_CHECK_FUNCS(gettimeofday,
2749 AC_TRY_COMPILE([#include <sys/time.h>],
2750 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2751 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2752 [Define if gettimeofday() does not have second (timezone) argument
2753 This is the case on Motorola V4 (R40V4.2)])
2757 AC_MSG_CHECKING(for major, minor, and makedev)
2759 #if defined(MAJOR_IN_MKDEV)
2760 #include <sys/mkdev.h>
2761 #elif defined(MAJOR_IN_SYSMACROS)
2762 #include <sys/sysmacros.h>
2764 #include <sys/types.h>
2767 makedev(major(0),minor(0));
2769 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2770 [Define to 1 if you have the device macros.])
2776 # On OSF/1 V5.1, getaddrinfo is available, but a define
2777 # for [no]getaddrinfo in netdb.h.
2778 AC_MSG_CHECKING(for getaddrinfo)
2780 #include <sys/types.h>
2781 #include <sys/socket.h>
2785 getaddrinfo(NULL, NULL, NULL, NULL);
2788 AC_MSG_CHECKING(getaddrinfo bug)
2790 #include <sys/types.h>
2793 #include <sys/socket.h>
2794 #include <netinet/in.h>
2798 int passive, gaierr, inet4 = 0, inet6 = 0;
2799 struct addrinfo hints, *ai, *aitop;
2800 char straddr[INET6_ADDRSTRLEN], strport[16];
2802 for (passive = 0; passive <= 1; passive++) {
2803 memset(&hints, 0, sizeof(hints));
2804 hints.ai_family = AF_UNSPEC;
2805 hints.ai_flags = passive ? AI_PASSIVE : 0;
2806 hints.ai_socktype = SOCK_STREAM;
2807 hints.ai_protocol = IPPROTO_TCP;
2808 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2809 (void)gai_strerror(gaierr);
2812 for (ai = aitop; ai; ai = ai->ai_next) {
2813 if (ai->ai_addr == NULL ||
2814 ai->ai_addrlen == 0 ||
2815 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2816 straddr, sizeof(straddr), strport, sizeof(strport),
2817 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2820 switch (ai->ai_family) {
2822 if (strcmp(strport, "54321") != 0) {
2826 if (strcmp(straddr, "0.0.0.0") != 0) {
2830 if (strcmp(straddr, "127.0.0.1") != 0) {
2837 if (strcmp(strport, "54321") != 0) {
2841 if (strcmp(straddr, "::") != 0) {
2845 if (strcmp(straddr, "::1") != 0) {
2855 /* another family support? */
2861 if (!(inet4 == 0 || inet4 == 2))
2863 if (!(inet6 == 0 || inet6 == 2))
2867 freeaddrinfo(aitop);
2872 freeaddrinfo(aitop);
2877 buggygetaddrinfo=no,
2878 AC_MSG_RESULT(buggy)
2879 buggygetaddrinfo=yes,
2880 AC_MSG_RESULT(buggy)
2881 buggygetaddrinfo=yes)], [
2883 buggygetaddrinfo=yes
2886 if test "$buggygetaddrinfo" = "yes"; then
2887 if test "$ipv6" = "yes"; then
2888 echo 'Fatal: You must get working getaddrinfo() function.'
2889 echo ' or you can specify "--disable-ipv6"'.
2893 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2895 AC_CHECK_FUNCS(getnameinfo)
2897 # checks for structures
2901 AC_CHECK_MEMBERS([struct stat.st_rdev])
2902 AC_CHECK_MEMBERS([struct stat.st_blksize])
2903 AC_CHECK_MEMBERS([struct stat.st_flags])
2904 AC_CHECK_MEMBERS([struct stat.st_gen])
2905 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2908 AC_MSG_CHECKING(for time.h that defines altzone)
2909 AC_CACHE_VAL(ac_cv_header_time_altzone,
2910 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2911 ac_cv_header_time_altzone=yes,
2912 ac_cv_header_time_altzone=no)])
2913 AC_MSG_RESULT($ac_cv_header_time_altzone)
2914 if test $ac_cv_header_time_altzone = yes; then
2915 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2919 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2921 #include <sys/types.h>
2922 #include <sys/select.h>
2923 #include <sys/time.h>
2925 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2926 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2927 (which you can't on SCO ODT 3.0).])
2930 AC_MSG_RESULT($was_it_defined)
2932 AC_MSG_CHECKING(for addrinfo)
2933 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2935 # include <netdb.h>],
2936 [struct addrinfo a],
2937 ac_cv_struct_addrinfo=yes,
2938 ac_cv_struct_addrinfo=no))
2939 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2940 if test $ac_cv_struct_addrinfo = yes; then
2941 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2944 AC_MSG_CHECKING(for sockaddr_storage)
2945 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2947 # include <sys/types.h>
2948 # include <sys/socket.h>],
2949 [struct sockaddr_storage s],
2950 ac_cv_struct_sockaddr_storage=yes,
2951 ac_cv_struct_sockaddr_storage=no))
2952 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2953 if test $ac_cv_struct_sockaddr_storage = yes; then
2954 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2957 # checks for compiler characteristics
2963 AC_MSG_CHECKING(for working volatile)
2964 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2965 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2967 AC_MSG_RESULT($works)
2970 AC_MSG_CHECKING(for working signed char)
2971 AC_TRY_COMPILE([], [signed char c;], works=yes,
2972 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2974 AC_MSG_RESULT($works)
2977 AC_MSG_CHECKING(for prototypes)
2978 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2979 AC_DEFINE(HAVE_PROTOTYPES, 1,
2980 [Define if your compiler supports function prototype])
2983 AC_MSG_RESULT($have_prototypes)
2986 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2989 int foo(int x, ...) {
2997 ], [return foo(10, "", 3.14);], [
2998 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2999 [Define if your compiler supports variable length function prototypes
3000 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
3003 AC_MSG_RESULT($works)
3005 # check for socketpair
3006 AC_MSG_CHECKING(for socketpair)
3008 #include <sys/types.h>
3009 #include <sys/socket.h>
3010 ], void *x=socketpair,
3011 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
3016 # check if sockaddr has sa_len member
3017 AC_MSG_CHECKING(if sockaddr has sa_len member)
3018 AC_TRY_COMPILE([#include <sys/types.h>
3019 #include <sys/socket.h>],
3023 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
3027 AC_MSG_CHECKING(whether va_list is an array)
3029 #ifdef HAVE_STDARG_PROTOTYPES
3032 #include <varargs.h>
3034 ], [va_list list1, list2; list1 = list2;], , [
3035 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
3036 va_list_is_array=yes
3038 AC_MSG_RESULT($va_list_is_array)
3040 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
3041 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
3042 [Define this if you have some version of gethostbyname_r()])
3044 AC_CHECK_FUNC(gethostbyname_r, [
3045 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3046 AC_MSG_CHECKING([gethostbyname_r with 6 args])
3048 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
3053 struct hostent *he, *res;
3058 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
3060 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3061 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
3062 [Define this if you have the 6-arg version of gethostbyname_r().])
3066 AC_MSG_CHECKING([gethostbyname_r with 5 args])
3076 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
3078 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3079 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
3080 [Define this if you have the 5-arg version of gethostbyname_r().])
3084 AC_MSG_CHECKING([gethostbyname_r with 3 args])
3090 struct hostent_data data;
3092 (void) gethostbyname_r(name, he, &data);
3094 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3095 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
3096 [Define this if you have the 3-arg version of gethostbyname_r().])
3105 AC_CHECK_FUNCS(gethostbyname)
3107 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
3108 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
3109 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
3110 AC_SUBST(HAVE_GETHOSTBYNAME_R)
3111 AC_SUBST(HAVE_GETHOSTBYNAME)
3113 # checks for system services
3116 # Linux requires this for correct f.p. operations
3117 AC_CHECK_FUNC(__fpu_control,
3119 [AC_CHECK_LIB(ieee, __fpu_control)
3122 # Check for --with-fpectl
3123 AC_MSG_CHECKING(for --with-fpectl)
3125 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
3127 if test "$withval" != no
3129 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
3130 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
3132 else AC_MSG_RESULT(no)
3134 [AC_MSG_RESULT(no)])
3136 # check for --with-libm=...
3138 case $ac_sys_system in
3143 AC_MSG_CHECKING(for --with-libm=STRING)
3145 AC_HELP_STRING(--with-libm=STRING, math library),
3147 if test "$withval" = no
3149 AC_MSG_RESULT(force LIBM empty)
3150 elif test "$withval" != yes
3152 AC_MSG_RESULT(set LIBM="$withval")
3153 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
3155 [AC_MSG_RESULT(default LIBM="$LIBM")])
3157 # check for --with-libc=...
3159 AC_MSG_CHECKING(for --with-libc=STRING)
3161 AC_HELP_STRING(--with-libc=STRING, C library),
3163 if test "$withval" = no
3165 AC_MSG_RESULT(force LIBC empty)
3166 elif test "$withval" != yes
3168 AC_MSG_RESULT(set LIBC="$withval")
3169 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
3171 [AC_MSG_RESULT(default LIBC="$LIBC")])
3173 # ************************************
3174 # * Check for mathematical functions *
3175 # ************************************
3180 # Detect whether system arithmetic is subject to x87-style double
3181 # rounding issues. The result of this test has little meaning on non
3182 # IEEE 754 platforms. On IEEE 754, test should return 1 if rounding
3183 # mode is round-to-nearest and double rounding issues are present, and
3184 # 0 otherwise. See http://bugs.python.org/issue2937 for more info.
3185 AC_MSG_CHECKING(for x87-style double rounding)
3186 AC_CACHE_VAL(ac_cv_x87_double_rounding, [
3191 volatile double x, y, z;
3192 /* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */
3193 x = 0.99999999999999989; /* 1-2**-53 */
3197 /* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
3203 /* both tests show evidence of double rounding */
3207 ac_cv_x87_double_rounding=no,
3208 ac_cv_x87_double_rounding=yes,
3209 ac_cv_x87_double_rounding=no)])
3210 AC_MSG_RESULT($ac_cv_x87_double_rounding)
3211 if test "$ac_cv_x87_double_rounding" = yes
3213 AC_DEFINE(X87_DOUBLE_ROUNDING, 1,
3214 [Define if arithmetic is subject to x87-style double rounding issue])
3217 # Multiprocessing check for broken sem_getvalue
3218 AC_MSG_CHECKING(for broken sem_getvalue)
3223 #include <semaphore.h>
3224 #include <sys/stat.h>
3227 sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR|S_IWUSR, 0);
3235 res = sem_getvalue(a, &count);
3237 return res==-1 ? 1 : 0;
3242 AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1, define to 1 if your sem_getvalue is broken.)
3245 # On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
3246 # -0. on some architectures.
3247 AC_MSG_CHECKING(whether tanh preserves the sign of zero)
3248 AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
3253 /* return 0 if either negative zeros don't exist
3254 on this platform or if negative zeros exist
3255 and tanh(-0.) == -0. */
3256 if (atan2(0., -1.) == atan2(-0., -1.) ||
3257 atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
3261 ac_cv_tanh_preserves_zero_sign=yes,
3262 ac_cv_tanh_preserves_zero_sign=no,
3263 ac_cv_tanh_preserves_zero_sign=no)])
3264 AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
3265 if test "$ac_cv_tanh_preserves_zero_sign" = yes
3267 AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
3268 [Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
3271 AC_CHECK_FUNCS([acosh asinh atanh copysign expm1 finite hypot log1p round])
3272 AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]])
3276 # determine what size digit to use for Python's longs
3277 AC_MSG_CHECKING([digit size for Python's longs])
3278 AC_ARG_ENABLE(big-digits,
3279 AC_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
3280 [case $enable_big_digits in
3282 enable_big_digits=30 ;;
3284 enable_big_digits=15 ;;
3288 AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
3290 AC_MSG_RESULT($enable_big_digits)
3291 AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits])
3293 [AC_MSG_RESULT(no value specified)])
3296 AC_CHECK_HEADER(wchar.h, [
3297 AC_DEFINE(HAVE_WCHAR_H, 1,
3298 [Define if the compiler provides a wchar.h header file.])
3304 # determine wchar_t size
3305 if test "$wchar_h" = yes
3307 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
3310 AC_MSG_CHECKING(for UCS-4 tcl)
3314 #if TCL_UTF_MAX != 6
3315 # error "NOT UCS4_TCL"
3317 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
3320 AC_MSG_RESULT($have_ucs4_tcl)
3322 # check whether wchar_t is signed or not
3323 if test "$wchar_h" = yes
3325 # check whether wchar_t is signed or not
3326 AC_MSG_CHECKING(whether wchar_t is signed)
3327 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
3332 /* Success: exit code 0 */
3333 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
3336 ac_cv_wchar_t_signed=yes,
3337 ac_cv_wchar_t_signed=no,
3338 ac_cv_wchar_t_signed=yes)])
3339 AC_MSG_RESULT($ac_cv_wchar_t_signed)
3342 AC_MSG_CHECKING(what type to use for unicode)
3343 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
3344 AC_ARG_ENABLE(unicode,
3345 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
3347 [enable_unicode=yes])
3349 if test $enable_unicode = yes
3351 # Without any arguments, Py_UNICODE defaults to two-byte mode
3352 case "$have_ucs4_tcl" in
3353 yes) enable_unicode="ucs4"
3355 *) enable_unicode="ucs2"
3360 AH_TEMPLATE(Py_UNICODE_SIZE,
3361 [Define as the size of the unicode type.])
3362 case "$enable_unicode" in
3363 ucs2) unicode_size="2"
3364 AC_DEFINE(Py_UNICODE_SIZE,2)
3366 ucs4) unicode_size="4"
3367 AC_DEFINE(Py_UNICODE_SIZE,4)
3371 AH_TEMPLATE(PY_UNICODE_TYPE,
3372 [Define as the integral type used for Unicode representation.])
3374 AC_SUBST(UNICODE_OBJS)
3375 if test "$enable_unicode" = "no"
3378 AC_MSG_RESULT(not used)
3380 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
3381 AC_DEFINE(Py_USING_UNICODE, 1,
3382 [Define if you want to have a Unicode type.])
3384 # wchar_t is only usable if it maps to an unsigned type
3385 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3386 -a "$ac_cv_wchar_t_signed" = "no"
3388 PY_UNICODE_TYPE="wchar_t"
3389 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3390 [Define if you have a useable wchar_t type defined in wchar.h; useable
3391 means wchar_t must be an unsigned type with at least 16 bits. (see
3392 Include/unicodeobject.h).])
3393 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3394 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3396 PY_UNICODE_TYPE="unsigned short"
3397 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3398 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3400 PY_UNICODE_TYPE="unsigned long"
3401 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3403 PY_UNICODE_TYPE="no type found"
3405 AC_MSG_RESULT($PY_UNICODE_TYPE)
3408 # check for endianness
3411 # Check whether right shifting a negative integer extends the sign bit
3412 # or fills with zeros (like the Cray J90, according to Tim Peters).
3413 AC_MSG_CHECKING(whether right shift extends the sign bit)
3414 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3418 exit(((-1)>>3 == -1) ? 0 : 1);
3421 ac_cv_rshift_extends_sign=yes,
3422 ac_cv_rshift_extends_sign=no,
3423 ac_cv_rshift_extends_sign=yes)])
3424 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3425 if test "$ac_cv_rshift_extends_sign" = no
3427 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3428 [Define if i>>j for signed int i does not extend the sign bit
3432 # check for getc_unlocked and related locking functions
3433 AC_MSG_CHECKING(for getc_unlocked() and friends)
3434 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3435 AC_TRY_LINK([#include <stdio.h>],[
3436 FILE *f = fopen("/dev/null", "r");
3440 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3441 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3442 if test "$ac_cv_have_getc_unlocked" = yes
3444 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3445 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3448 # check where readline lives
3449 # save the value of LIBS so we don't actually link Python with readline
3450 LIBS_no_readline=$LIBS
3452 # On some systems we need to link readline to a termcap compatible
3453 # library. NOTE: Keep the precedence of listed libraries synchronised
3455 py_cv_lib_readline=no
3456 AC_MSG_CHECKING([how to link readline libs])
3457 for py_libtermcap in "" ncursesw ncurses curses termcap; do
3458 if test -z "$py_libtermcap"; then
3459 READLINE_LIBS="-lreadline"
3461 READLINE_LIBS="-lreadline -l$py_libtermcap"
3463 LIBS="$READLINE_LIBS $LIBS_no_readline"
3465 [AC_LANG_CALL([],[readline])],
3466 [py_cv_lib_readline=yes])
3467 if test $py_cv_lib_readline = yes; then
3471 # Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
3472 #AC_SUBST([READLINE_LIBS])
3473 if test $py_cv_lib_readline = no; then
3474 AC_MSG_RESULT([none])
3476 AC_MSG_RESULT([$READLINE_LIBS])
3477 AC_DEFINE(HAVE_LIBREADLINE, 1,
3478 [Define if you have the readline library (-lreadline).])
3481 # check for readline 2.1
3482 AC_CHECK_LIB(readline, rl_callback_handler_install,
3483 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3484 [Define if you have readline 2.1]), ,$READLINE_LIBS)
3486 # check for readline 2.2
3487 AC_TRY_CPP([#include <readline/readline.h>],
3488 have_readline=yes, have_readline=no)
3489 if test $have_readline = yes
3491 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3492 [readline/readline.h],
3493 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3494 [Define if you have readline 2.2]), )
3497 # check for readline 4.0
3498 AC_CHECK_LIB(readline, rl_pre_input_hook,
3499 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3500 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3503 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
3504 AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
3505 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3507 # check for readline 4.2
3508 AC_CHECK_LIB(readline, rl_completion_matches,
3509 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3510 [Define if you have readline 4.2]), ,$READLINE_LIBS)
3512 # also in readline 4.2
3513 AC_TRY_CPP([#include <readline/readline.h>],
3514 have_readline=yes, have_readline=no)
3515 if test $have_readline = yes
3517 AC_EGREP_HEADER([extern int rl_catch_signals;],
3518 [readline/readline.h],
3519 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3520 [Define if you can turn off readline's signal handling.]), )
3523 # End of readline checks: restore LIBS
3524 LIBS=$LIBS_no_readline
3526 AC_MSG_CHECKING(for broken nice())
3527 AC_CACHE_VAL(ac_cv_broken_nice, [
3532 if (val1 != -1 && val1 == nice(2))
3537 ac_cv_broken_nice=yes,
3538 ac_cv_broken_nice=no,
3539 ac_cv_broken_nice=no)])
3540 AC_MSG_RESULT($ac_cv_broken_nice)
3541 if test "$ac_cv_broken_nice" = yes
3543 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3544 [Define if nice() returns success/failure instead of the new priority.])
3547 AC_MSG_CHECKING(for broken poll())
3553 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3557 int poll_test = poll (&poll_struct, 1, 0);
3563 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3573 ac_cv_broken_poll=yes,
3574 ac_cv_broken_poll=no,
3575 ac_cv_broken_poll=no)
3576 AC_MSG_RESULT($ac_cv_broken_poll)
3577 if test "$ac_cv_broken_poll" = yes
3579 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3580 [Define if poll() sets errno on invalid file descriptors.])
3583 # Before we can test tzset, we need to check if struct tm has a tm_zone
3584 # (which is not required by ISO C or UNIX spec) and/or if we support
3588 # check tzset(3) exists and works like we expect it to
3589 AC_MSG_CHECKING(for working tzset())
3590 AC_CACHE_VAL(ac_cv_working_tzset, [
3597 extern char *tzname[];
3602 /* Note that we need to ensure that not only does tzset(3)
3603 do 'something' with localtime, but it works as documented
3604 in the library reference and as expected by the test suite.
3605 This includes making sure that tzname is set properly if
3606 tm->tm_zone does not exist since it is the alternative way
3607 of getting timezone info.
3609 Red Hat 6.2 doesn't understand the southern hemisphere
3610 after New Year's Day.
3613 time_t groundhogday = 1044144000; /* GMT-based */
3614 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3618 if (localtime(&groundhogday)->tm_hour != 0)
3621 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3622 if (strcmp(tzname[0], "UTC") ||
3623 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3627 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3629 if (localtime(&groundhogday)->tm_hour != 19)
3632 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3636 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3638 if (localtime(&groundhogday)->tm_hour != 11)
3641 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3645 #if HAVE_STRUCT_TM_TM_ZONE
3646 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3648 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3655 ac_cv_working_tzset=yes,
3656 ac_cv_working_tzset=no,
3657 ac_cv_working_tzset=no)])
3658 AC_MSG_RESULT($ac_cv_working_tzset)
3659 if test "$ac_cv_working_tzset" = yes
3661 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3662 [Define if tzset() actually switches the local timezone in a meaningful way.])
3665 # Look for subsecond timestamps in struct stat
3666 AC_MSG_CHECKING(for tv_nsec in struct stat)
3667 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3668 AC_TRY_COMPILE([#include <sys/stat.h>], [
3670 st.st_mtim.tv_nsec = 1;
3672 ac_cv_stat_tv_nsec=yes,
3673 ac_cv_stat_tv_nsec=no,
3674 ac_cv_stat_tv_nsec=no))
3675 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3676 if test "$ac_cv_stat_tv_nsec" = yes
3678 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3679 [Define if you have struct stat.st_mtim.tv_nsec])
3682 # Look for BSD style subsecond timestamps in struct stat
3683 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3684 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3685 AC_TRY_COMPILE([#include <sys/stat.h>], [
3687 st.st_mtimespec.tv_nsec = 1;
3689 ac_cv_stat_tv_nsec2=yes,
3690 ac_cv_stat_tv_nsec2=no,
3691 ac_cv_stat_tv_nsec2=no))
3692 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3693 if test "$ac_cv_stat_tv_nsec2" = yes
3695 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3696 [Define if you have struct stat.st_mtimensec])
3699 # On HP/UX 11.0, mvwdelch is a block with a return statement
3700 AC_MSG_CHECKING(whether mvwdelch is an expression)
3701 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3702 AC_TRY_COMPILE([#include <curses.h>], [
3704 rtn = mvwdelch(0,0,0);
3705 ], ac_cv_mvwdelch_is_expression=yes,
3706 ac_cv_mvwdelch_is_expression=no,
3707 ac_cv_mvwdelch_is_expression=yes))
3708 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3710 if test "$ac_cv_mvwdelch_is_expression" = yes
3712 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3713 [Define if mvwdelch in curses.h is an expression.])
3716 AC_MSG_CHECKING(whether WINDOW has _flags)
3717 AC_CACHE_VAL(ac_cv_window_has_flags,
3718 AC_TRY_COMPILE([#include <curses.h>], [
3721 ], ac_cv_window_has_flags=yes,
3722 ac_cv_window_has_flags=no,
3723 ac_cv_window_has_flags=no))
3724 AC_MSG_RESULT($ac_cv_window_has_flags)
3727 if test "$ac_cv_window_has_flags" = yes
3729 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3730 [Define if WINDOW in curses.h offers a field _flags.])
3733 AC_MSG_CHECKING(for is_term_resized)
3734 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3735 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3740 AC_MSG_CHECKING(for resize_term)
3741 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3742 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3747 AC_MSG_CHECKING(for resizeterm)
3748 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3749 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3754 AC_MSG_CHECKING(for /dev/ptmx)
3756 if test -r /dev/ptmx
3759 AC_DEFINE(HAVE_DEV_PTMX, 1,
3760 [Define if we have /dev/ptmx.])
3765 AC_MSG_CHECKING(for /dev/ptc)
3770 AC_DEFINE(HAVE_DEV_PTC, 1,
3771 [Define if we have /dev/ptc.])
3776 AC_MSG_CHECKING(for %zd printf() format support)
3777 AC_TRY_RUN([#include <stdio.h>
3781 #ifdef HAVE_SYS_TYPES_H
3782 #include <sys/types.h>
3786 typedef ssize_t Py_ssize_t;
3787 #elif SIZEOF_VOID_P == SIZEOF_LONG
3788 typedef long Py_ssize_t;
3790 typedef int Py_ssize_t;
3797 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3800 if (strcmp(buffer, "123"))
3803 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3806 if (strcmp(buffer, "-123"))
3812 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3815 AC_CHECK_TYPE(socklen_t,,
3816 AC_DEFINE(socklen_t,int,
3817 Define to `int' if <sys/socket.h> does not define.),[
3818 #ifdef HAVE_SYS_TYPES_H
3819 #include <sys/types.h>
3821 #ifdef HAVE_SYS_SOCKET_H
3822 #include <sys/socket.h>
3826 AC_SUBST(THREADHEADERS)
3828 for h in `(cd $srcdir;echo Python/thread_*.h)`
3830 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3834 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3835 AC_MSG_CHECKING(for build directories)
3836 for dir in $SRCDIRS; do
3837 if test ! -d $dir; then
3843 # generate output files
3844 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3847 echo "creating Modules/Setup"
3848 if test ! -f Modules/Setup
3850 cp $srcdir/Modules/Setup.dist Modules/Setup
3853 echo "creating Modules/Setup.local"
3854 if test ! -f Modules/Setup.local
3856 echo "# Edit this file for local setup changes" >Modules/Setup.local
3859 echo "creating Makefile"
3860 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3861 -s Modules Modules/Setup.config \
3862 Modules/Setup.local Modules/Setup
3864 case $ac_sys_system in
3868 Support for BeOS is deprecated as of Python 2.6.
3869 See PEP 11 for the gory details.