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 # Determine if signalmodule should be used.
1922 AC_SUBST(USE_SIGNAL_MODULE)
1923 AC_SUBST(SIGNAL_OBJS)
1924 AC_MSG_CHECKING(for --with-signal-module)
1925 AC_ARG_WITH(signal-module,
1926 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1928 if test -z "$with_signal_module"
1929 then with_signal_module="yes"
1931 AC_MSG_RESULT($with_signal_module)
1933 if test "${with_signal_module}" = "yes"; then
1934 USE_SIGNAL_MODULE=""
1937 USE_SIGNAL_MODULE="#"
1938 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1941 # This is used to generate Setup.config
1942 AC_SUBST(USE_THREAD_MODULE)
1943 USE_THREAD_MODULE=""
1945 AC_MSG_CHECKING(for --with-dec-threads)
1947 AC_ARG_WITH(dec-threads,
1948 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1950 AC_MSG_RESULT($withval)
1952 if test "${with_thread+set}" != set; then
1953 with_thread="$withval";
1955 [AC_MSG_RESULT(no)])
1957 # Templates for things AC_DEFINEd more than once.
1958 # For a single AC_DEFINE, no template is needed.
1959 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1960 AH_TEMPLATE(_REENTRANT,
1961 [Define to force use of thread-safe errno, h_errno, and other functions])
1962 AH_TEMPLATE(WITH_THREAD,
1963 [Define if you want to compile in rudimentary thread support])
1965 AC_MSG_CHECKING(for --with-threads)
1966 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1967 AC_ARG_WITH(threads,
1968 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1970 # --with-thread is deprecated, but check for it anyway
1971 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1973 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1974 [with_threads=$with_thread])
1976 if test -z "$with_threads"
1977 then with_threads="yes"
1979 AC_MSG_RESULT($with_threads)
1982 if test "$with_threads" = "no"
1984 USE_THREAD_MODULE="#"
1985 elif test "$ac_cv_pthread_is_default" = yes
1987 AC_DEFINE(WITH_THREAD)
1988 # Defining _REENTRANT on system with POSIX threads should not hurt.
1989 AC_DEFINE(_REENTRANT)
1991 THREADOBJ="Python/thread.o"
1992 elif test "$ac_cv_kpthread" = "yes"
1995 if test "$ac_cv_cxx_thread" = "yes"; then
1996 CXX="$CXX -Kpthread"
1998 AC_DEFINE(WITH_THREAD)
2000 THREADOBJ="Python/thread.o"
2001 elif test "$ac_cv_kthread" = "yes"
2004 if test "$ac_cv_cxx_thread" = "yes"; then
2007 AC_DEFINE(WITH_THREAD)
2009 THREADOBJ="Python/thread.o"
2010 elif test "$ac_cv_pthread" = "yes"
2013 if test "$ac_cv_cxx_thread" = "yes"; then
2016 AC_DEFINE(WITH_THREAD)
2018 THREADOBJ="Python/thread.o"
2020 if test ! -z "$with_threads" -a -d "$with_threads"
2021 then LDFLAGS="$LDFLAGS -L$with_threads"
2023 if test ! -z "$withval" -a -d "$withval"
2024 then LDFLAGS="$LDFLAGS -L$withval"
2027 # According to the POSIX spec, a pthreads implementation must
2028 # define _POSIX_THREADS in unistd.h. Some apparently don't
2029 # (e.g. gnu pth with pthread emulation)
2030 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
2034 #ifdef _POSIX_THREADS
2037 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
2038 AC_MSG_RESULT($unistd_defines_pthreads)
2040 AC_DEFINE(_REENTRANT)
2041 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
2042 AC_DEFINE(C_THREADS)
2043 AC_DEFINE(HURD_C_THREADS, 1,
2044 [Define if you are using Mach cthreads directly under /include])
2045 LIBS="$LIBS -lthreads"
2046 THREADOBJ="Python/thread.o"],[
2047 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
2048 AC_DEFINE(C_THREADS)
2049 AC_DEFINE(MACH_C_THREADS, 1,
2050 [Define if you are using Mach cthreads under mach /])
2051 THREADOBJ="Python/thread.o"],[
2052 AC_MSG_CHECKING(for --with-pth)
2054 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
2055 [AC_MSG_RESULT($withval)
2056 AC_DEFINE([WITH_THREAD])
2057 AC_DEFINE([HAVE_PTH], 1,
2058 [Define if you have GNU PTH threads.])
2060 THREADOBJ="Python/thread.o"],
2063 # Just looking for pthread_create in libpthread is not enough:
2064 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
2065 # So we really have to include pthread.h, and then link.
2067 LIBS="$LIBS -lpthread"
2068 AC_MSG_CHECKING([for pthread_create in -lpthread])
2069 AC_TRY_LINK([#include <pthread.h>
2071 void * start_routine (void *arg) { exit (0); }], [
2072 pthread_create (NULL, NULL, start_routine, NULL)], [
2074 AC_DEFINE(WITH_THREAD)
2076 THREADOBJ="Python/thread.o"],[
2078 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
2080 THREADOBJ="Python/thread.o"],[
2081 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
2082 AC_DEFINE(ATHEOS_THREADS, 1,
2083 [Define this if you have AtheOS threads.])
2084 THREADOBJ="Python/thread.o"],[
2085 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
2086 AC_DEFINE(BEOS_THREADS, 1,
2087 [Define this if you have BeOS threads.])
2088 THREADOBJ="Python/thread.o"],[
2089 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
2091 LIBS="$LIBS -lpthreads"
2092 THREADOBJ="Python/thread.o"], [
2093 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
2096 THREADOBJ="Python/thread.o"], [
2097 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
2099 LIBS="$LIBS -lpthread"
2100 THREADOBJ="Python/thread.o"], [
2101 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
2104 THREADOBJ="Python/thread.o"],[
2105 USE_THREAD_MODULE="#"])
2106 ])])])])])])])])])])
2108 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
2110 THREADOBJ="Python/thread.o"
2111 USE_THREAD_MODULE=""])
2113 if test "$posix_threads" != "yes"; then
2114 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
2115 LIBS="$LIBS -lthread"
2116 THREADOBJ="Python/thread.o"
2117 USE_THREAD_MODULE=""])
2120 if test "$USE_THREAD_MODULE" != "#"
2122 # If the above checks didn't disable threads, (at least) OSF1
2123 # needs this '-threads' argument during linking.
2124 case $ac_sys_system in
2125 OSF1) LDLAST=-threads;;
2130 if test "$posix_threads" = "yes"; then
2131 if test "$unistd_defines_pthreads" = "no"; then
2132 AC_DEFINE(_POSIX_THREADS, 1,
2133 [Define if you have POSIX threads,
2134 and your system does not define that.])
2137 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
2138 case $ac_sys_system/$ac_sys_release in
2139 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
2140 Defined for Solaris 2.6 bug in pthread header.)
2142 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2143 Define if the Posix semaphores do not work on your system)
2145 AIX/5) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2146 Define if the Posix semaphores do not work on your system)
2150 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
2151 AC_CACHE_VAL(ac_cv_pthread_system_supported,
2152 [AC_TRY_RUN([#include <pthread.h>
2153 void *foo(void *parm) {
2157 pthread_attr_t attr;
2159 if (pthread_attr_init(&attr)) exit(-1);
2160 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
2161 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
2164 ac_cv_pthread_system_supported=yes,
2165 ac_cv_pthread_system_supported=no,
2166 ac_cv_pthread_system_supported=no)
2168 AC_MSG_RESULT($ac_cv_pthread_system_supported)
2169 if test "$ac_cv_pthread_system_supported" = "yes"; then
2170 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2172 AC_CHECK_FUNCS(pthread_sigmask,
2173 [case $ac_sys_system in
2175 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2176 [Define if pthread_sigmask() does not work on your system.])
2182 # Check for enable-ipv6
2183 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2184 AC_MSG_CHECKING([if --enable-ipv6 is specified])
2186 [ --enable-ipv6 Enable ipv6 (with ipv4) support
2187 --disable-ipv6 Disable ipv6 support],
2188 [ case "$enableval" in
2193 *) AC_MSG_RESULT(yes)
2194 AC_DEFINE(ENABLE_IPV6)
2200 dnl the check does not work on cross compilation case...
2201 AC_TRY_RUN([ /* AF_INET6 available check */
2202 #include <sys/types.h>
2203 #include <sys/socket.h>
2206 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2220 if test "$ipv6" = "yes"; then
2221 AC_MSG_CHECKING(if RFC2553 API is available)
2222 AC_TRY_COMPILE([#include <sys/types.h>
2223 #include <netinet/in.h>],
2224 [struct sockaddr_in6 x;
2228 AC_MSG_RESULT(no, IPv6 disabled)
2232 if test "$ipv6" = "yes"; then
2233 AC_DEFINE(ENABLE_IPV6)
2241 if test "$ipv6" = "yes"; then
2242 AC_MSG_CHECKING([ipv6 stack type])
2243 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2247 dnl http://www.kame.net/
2249 #include <netinet/in.h>
2250 #ifdef IPV6_INRIA_VERSION
2256 dnl http://www.kame.net/
2258 #include <netinet/in.h>
2264 ipv6libdir=/usr/local/v6/lib
2268 dnl http://www.v6.linux.or.jp/
2270 #include <features.h>
2271 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2278 dnl http://www.v6.linux.or.jp/
2279 if test -d /usr/inet6; then
2282 ipv6libdir=/usr/inet6/lib
2283 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2287 if test -f /etc/netconfig; then
2288 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2296 #include <sys/param.h>
2297 #ifdef _TOSHIBA_INET6
2302 ipv6libdir=/usr/local/v6/lib])
2306 #include </usr/local/v6/include/sys/v6config.h>
2312 ipv6libdir=/usr/local/v6/lib;
2313 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2317 #include <sys/param.h>
2318 #ifdef _ZETA_MINAMI_INET6
2323 ipv6libdir=/usr/local/v6/lib])
2326 if test "$ipv6type" != "unknown"; then
2330 AC_MSG_RESULT($ipv6type)
2333 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2334 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2335 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2336 echo "using lib$ipv6lib"
2338 if test $ipv6trylibc = "yes"; then
2341 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2342 echo "You need to fetch lib$ipv6lib.a from appropriate"
2343 echo 'ipv6 kit and compile beforehand.'
2349 AC_MSG_CHECKING(for OSX 10.5 SDK or later)
2350 AC_TRY_COMPILE([#include <Carbon/Carbon.h>], FSIORefNum fRef = 0,
2351 AC_DEFINE(HAVE_OSX105_SDK, 1, Define if compiling using MacOS X 10.5 SDK or later.)
2356 # Check for --with-doc-strings
2357 AC_MSG_CHECKING(for --with-doc-strings)
2358 AC_ARG_WITH(doc-strings,
2359 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2361 if test -z "$with_doc_strings"
2362 then with_doc_strings="yes"
2364 if test "$with_doc_strings" != "no"
2366 AC_DEFINE(WITH_DOC_STRINGS, 1,
2367 [Define if you want documentation strings in extension modules])
2369 AC_MSG_RESULT($with_doc_strings)
2371 # Check for Python-specific malloc support
2372 AC_MSG_CHECKING(for --with-tsc)
2374 [ --with(out)-tsc enable/disable timestamp counter profile], [
2375 if test "$withval" != no
2377 AC_DEFINE(WITH_TSC, 1,
2378 [Define to profile with the Pentium timestamp counter])
2380 else AC_MSG_RESULT(no)
2382 [AC_MSG_RESULT(no)])
2384 # Check for Python-specific malloc support
2385 AC_MSG_CHECKING(for --with-pymalloc)
2386 AC_ARG_WITH(pymalloc,
2387 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2389 if test -z "$with_pymalloc"
2390 then with_pymalloc="yes"
2392 if test "$with_pymalloc" != "no"
2394 AC_DEFINE(WITH_PYMALLOC, 1,
2395 [Define if you want to compile in Python-specific mallocs])
2397 AC_MSG_RESULT($with_pymalloc)
2399 # Check for --with-wctype-functions
2400 AC_MSG_CHECKING(for --with-wctype-functions)
2401 AC_ARG_WITH(wctype-functions,
2402 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2404 if test "$withval" != no
2406 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2407 [Define if you want wctype.h functions to be used instead of the
2408 one supplied by Python itself. (see Include/unicodectype.h).])
2410 else AC_MSG_RESULT(no)
2412 [AC_MSG_RESULT(no)])
2414 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2418 # the dlopen() function means we might want to use dynload_shlib.o. some
2419 # platforms, such as AIX, have dlopen(), but don't want to use it.
2420 AC_CHECK_FUNCS(dlopen)
2422 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2423 # loading of modules.
2424 AC_SUBST(DYNLOADFILE)
2425 AC_MSG_CHECKING(DYNLOADFILE)
2426 if test -z "$DYNLOADFILE"
2428 case $ac_sys_system/$ac_sys_release in
2429 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2430 if test "$ac_cv_func_dlopen" = yes
2431 then DYNLOADFILE="dynload_shlib.o"
2432 else DYNLOADFILE="dynload_aix.o"
2435 BeOS*) DYNLOADFILE="dynload_beos.o";;
2436 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2437 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2438 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2439 atheos*) DYNLOADFILE="dynload_atheos.o";;
2441 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2442 # out any dynamic loading
2443 if test "$ac_cv_func_dlopen" = yes
2444 then DYNLOADFILE="dynload_shlib.o"
2445 else DYNLOADFILE="dynload_stub.o"
2450 AC_MSG_RESULT($DYNLOADFILE)
2451 if test "$DYNLOADFILE" != "dynload_stub.o"
2453 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2454 [Defined when any dynamic module loading is enabled.])
2457 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2459 AC_SUBST(MACHDEP_OBJS)
2460 AC_MSG_CHECKING(MACHDEP_OBJS)
2461 if test -z "$MACHDEP_OBJS"
2463 MACHDEP_OBJS=$extra_machdep_objs
2465 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2467 AC_MSG_RESULT(MACHDEP_OBJS)
2469 # checks for library functions
2470 AC_CHECK_FUNCS(alarm setitimer getitimer bind_textdomain_codeset chown \
2471 clock confstr ctermid execv fchmod fchown fork fpathconf ftime ftruncate \
2472 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2473 getpriority getpwent getspnam getspent getsid getwd \
2474 kill killpg lchmod lchown lstat mkfifo mknod mktime \
2475 mremap nice pathconf pause plock poll pthread_init \
2476 putenv readlink realpath \
2477 select setegid seteuid setgid \
2478 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2479 sigaction siginterrupt sigrelse strftime \
2480 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2481 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2483 # For some functions, having a definition is not sufficient, since
2484 # we want to take their address.
2485 AC_MSG_CHECKING(for chroot)
2486 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2487 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2491 AC_MSG_CHECKING(for link)
2492 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2493 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2497 AC_MSG_CHECKING(for symlink)
2498 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2499 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2503 AC_MSG_CHECKING(for fchdir)
2504 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2505 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2509 AC_MSG_CHECKING(for fsync)
2510 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2511 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2515 AC_MSG_CHECKING(for fdatasync)
2516 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2517 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2521 AC_MSG_CHECKING(for epoll)
2522 AC_TRY_COMPILE([#include <sys/epoll.h>], void *x=epoll_create,
2523 AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
2527 AC_MSG_CHECKING(for kqueue)
2529 #include <sys/types.h>
2530 #include <sys/event.h>
2532 AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
2536 # On some systems (eg. FreeBSD 5), we would find a definition of the
2537 # functions ctermid_r, setgroups in the library, but no prototype
2538 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2539 # address to avoid compiler warnings and potential miscompilations
2540 # because of the missing prototypes.
2542 AC_MSG_CHECKING(for ctermid_r)
2544 #include "confdefs.h"
2546 ], void* p = ctermid_r,
2547 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2552 AC_MSG_CHECKING(for flock)
2554 #include "confdefs.h"
2555 #include <sys/file.h>
2557 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2562 AC_MSG_CHECKING(for getpagesize)
2564 #include "confdefs.h"
2566 ], void* p = getpagesize,
2567 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2573 AC_CHECK_PROGS(TRUE, true, /bin/true)
2575 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2576 dnl On others, they are in the C library, so we to take no action
2577 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2578 AC_CHECK_LIB(resolv, inet_aton)
2581 # On Tru64, chflags seems to be present, but calling it will
2583 AC_MSG_CHECKING(for chflags)
2585 #include <sys/stat.h>
2587 int main(int argc, char*argv[])
2589 if(chflags(argv[0], 0) != 0)
2593 ],AC_DEFINE(HAVE_CHFLAGS, 1, Define to 1 if you have the `chflags' function.)
2598 AC_MSG_CHECKING(for lchflags)
2600 #include <sys/stat.h>
2602 int main(int argc, char*argv[])
2604 if(lchflags(argv[0], 0) != 0)
2608 ],AC_DEFINE(HAVE_LCHFLAGS, 1, Define to 1 if you have the `lchflags' function.)
2613 dnl Check if system zlib has *Copy() functions
2615 dnl On MacOSX the linker will search for dylibs on the entire linker path
2616 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2617 dnl to revert to a more traditional unix behaviour and make it possible to
2618 dnl override the system libz with a local static library of libz. Temporarily
2619 dnl add that flag to our CFLAGS as well to ensure that we check the version
2620 dnl of libz that will be used by setup.py.
2621 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2622 dnl environment as setup.py (and leaving it out can cause configure to use the
2623 dnl wrong version of the library)
2624 case $ac_sys_system/$ac_sys_release in
2626 _CUR_CFLAGS="${CFLAGS}"
2627 _CUR_LDFLAGS="${LDFLAGS}"
2628 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2629 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2633 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2635 case $ac_sys_system/$ac_sys_release in
2637 CFLAGS="${_CUR_CFLAGS}"
2638 LDFLAGS="${_CUR_LDFLAGS}"
2642 AC_MSG_CHECKING(for hstrerror)
2644 #include "confdefs.h"
2646 ], void* p = hstrerror; hstrerror(0),
2647 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2652 AC_MSG_CHECKING(for inet_aton)
2654 #include "confdefs.h"
2655 #include <sys/types.h>
2656 #include <sys/socket.h>
2657 #include <netinet/in.h>
2658 #include <arpa/inet.h>
2659 ], void* p = inet_aton;inet_aton(0,0),
2660 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2665 AC_MSG_CHECKING(for inet_pton)
2667 #include "confdefs.h"
2668 #include <sys/types.h>
2669 #include <sys/socket.h>
2670 #include <netinet/in.h>
2671 #include <arpa/inet.h>
2672 ], void* p = inet_pton,
2673 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2678 # On some systems, setgroups is in unistd.h, on others, in grp.h
2679 AC_MSG_CHECKING(for setgroups)
2681 #include "confdefs.h"
2687 void* p = setgroups,
2688 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2693 # check for openpty and forkpty
2695 AC_CHECK_FUNCS(openpty,,
2696 AC_CHECK_LIB(util,openpty,
2697 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2698 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2701 AC_CHECK_FUNCS(forkpty,,
2702 AC_CHECK_LIB(util,forkpty,
2703 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2704 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2709 AC_CHECK_FUNCS(memmove)
2711 # check for long file support functions
2712 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2714 AC_REPLACE_FUNCS(dup2 getcwd strdup)
2715 AC_CHECK_FUNCS(getpgrp,
2716 AC_TRY_COMPILE([#include <unistd.h>],
2718 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2719 [Define if getpgrp() must be called as getpgrp(0).])
2722 AC_CHECK_FUNCS(setpgrp,
2723 AC_TRY_COMPILE([#include <unistd.h>],
2725 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2726 [Define if setpgrp() must be called as setpgrp(0, 0).])
2729 AC_CHECK_FUNCS(gettimeofday,
2730 AC_TRY_COMPILE([#include <sys/time.h>],
2731 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2732 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2733 [Define if gettimeofday() does not have second (timezone) argument
2734 This is the case on Motorola V4 (R40V4.2)])
2738 AC_MSG_CHECKING(for major, minor, and makedev)
2740 #if defined(MAJOR_IN_MKDEV)
2741 #include <sys/mkdev.h>
2742 #elif defined(MAJOR_IN_SYSMACROS)
2743 #include <sys/sysmacros.h>
2745 #include <sys/types.h>
2748 makedev(major(0),minor(0));
2750 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2751 [Define to 1 if you have the device macros.])
2757 # On OSF/1 V5.1, getaddrinfo is available, but a define
2758 # for [no]getaddrinfo in netdb.h.
2759 AC_MSG_CHECKING(for getaddrinfo)
2761 #include <sys/types.h>
2762 #include <sys/socket.h>
2766 getaddrinfo(NULL, NULL, NULL, NULL);
2769 AC_MSG_CHECKING(getaddrinfo bug)
2771 #include <sys/types.h>
2774 #include <sys/socket.h>
2775 #include <netinet/in.h>
2779 int passive, gaierr, inet4 = 0, inet6 = 0;
2780 struct addrinfo hints, *ai, *aitop;
2781 char straddr[INET6_ADDRSTRLEN], strport[16];
2783 for (passive = 0; passive <= 1; passive++) {
2784 memset(&hints, 0, sizeof(hints));
2785 hints.ai_family = AF_UNSPEC;
2786 hints.ai_flags = passive ? AI_PASSIVE : 0;
2787 hints.ai_socktype = SOCK_STREAM;
2788 hints.ai_protocol = IPPROTO_TCP;
2789 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2790 (void)gai_strerror(gaierr);
2793 for (ai = aitop; ai; ai = ai->ai_next) {
2794 if (ai->ai_addr == NULL ||
2795 ai->ai_addrlen == 0 ||
2796 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2797 straddr, sizeof(straddr), strport, sizeof(strport),
2798 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2801 switch (ai->ai_family) {
2803 if (strcmp(strport, "54321") != 0) {
2807 if (strcmp(straddr, "0.0.0.0") != 0) {
2811 if (strcmp(straddr, "127.0.0.1") != 0) {
2818 if (strcmp(strport, "54321") != 0) {
2822 if (strcmp(straddr, "::") != 0) {
2826 if (strcmp(straddr, "::1") != 0) {
2836 /* another family support? */
2842 if (!(inet4 == 0 || inet4 == 2))
2844 if (!(inet6 == 0 || inet6 == 2))
2848 freeaddrinfo(aitop);
2853 freeaddrinfo(aitop);
2858 buggygetaddrinfo=no,
2859 AC_MSG_RESULT(buggy)
2860 buggygetaddrinfo=yes,
2861 AC_MSG_RESULT(buggy)
2862 buggygetaddrinfo=yes)], [
2864 buggygetaddrinfo=yes
2867 if test "$buggygetaddrinfo" = "yes"; then
2868 if test "$ipv6" = "yes"; then
2869 echo 'Fatal: You must get working getaddrinfo() function.'
2870 echo ' or you can specify "--disable-ipv6"'.
2874 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2876 AC_CHECK_FUNCS(getnameinfo)
2878 # checks for structures
2882 AC_CHECK_MEMBERS([struct stat.st_rdev])
2883 AC_CHECK_MEMBERS([struct stat.st_blksize])
2884 AC_CHECK_MEMBERS([struct stat.st_flags])
2885 AC_CHECK_MEMBERS([struct stat.st_gen])
2886 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2889 AC_MSG_CHECKING(for time.h that defines altzone)
2890 AC_CACHE_VAL(ac_cv_header_time_altzone,
2891 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2892 ac_cv_header_time_altzone=yes,
2893 ac_cv_header_time_altzone=no)])
2894 AC_MSG_RESULT($ac_cv_header_time_altzone)
2895 if test $ac_cv_header_time_altzone = yes; then
2896 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2900 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2902 #include <sys/types.h>
2903 #include <sys/select.h>
2904 #include <sys/time.h>
2906 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2907 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2908 (which you can't on SCO ODT 3.0).])
2911 AC_MSG_RESULT($was_it_defined)
2913 AC_MSG_CHECKING(for addrinfo)
2914 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2916 # include <netdb.h>],
2917 [struct addrinfo a],
2918 ac_cv_struct_addrinfo=yes,
2919 ac_cv_struct_addrinfo=no))
2920 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2921 if test $ac_cv_struct_addrinfo = yes; then
2922 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2925 AC_MSG_CHECKING(for sockaddr_storage)
2926 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2928 # include <sys/types.h>
2929 # include <sys/socket.h>],
2930 [struct sockaddr_storage s],
2931 ac_cv_struct_sockaddr_storage=yes,
2932 ac_cv_struct_sockaddr_storage=no))
2933 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2934 if test $ac_cv_struct_sockaddr_storage = yes; then
2935 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2938 # checks for compiler characteristics
2944 AC_MSG_CHECKING(for working volatile)
2945 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2946 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2948 AC_MSG_RESULT($works)
2951 AC_MSG_CHECKING(for working signed char)
2952 AC_TRY_COMPILE([], [signed char c;], works=yes,
2953 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2955 AC_MSG_RESULT($works)
2958 AC_MSG_CHECKING(for prototypes)
2959 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2960 AC_DEFINE(HAVE_PROTOTYPES, 1,
2961 [Define if your compiler supports function prototype])
2964 AC_MSG_RESULT($have_prototypes)
2967 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2970 int foo(int x, ...) {
2978 ], [return foo(10, "", 3.14);], [
2979 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2980 [Define if your compiler supports variable length function prototypes
2981 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2984 AC_MSG_RESULT($works)
2986 # check for socketpair
2987 AC_MSG_CHECKING(for socketpair)
2989 #include <sys/types.h>
2990 #include <sys/socket.h>
2991 ], void *x=socketpair,
2992 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2997 # check if sockaddr has sa_len member
2998 AC_MSG_CHECKING(if sockaddr has sa_len member)
2999 AC_TRY_COMPILE([#include <sys/types.h>
3000 #include <sys/socket.h>],
3004 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
3008 AC_MSG_CHECKING(whether va_list is an array)
3010 #ifdef HAVE_STDARG_PROTOTYPES
3013 #include <varargs.h>
3015 ], [va_list list1, list2; list1 = list2;], , [
3016 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
3017 va_list_is_array=yes
3019 AC_MSG_RESULT($va_list_is_array)
3021 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
3022 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
3023 [Define this if you have some version of gethostbyname_r()])
3025 AC_CHECK_FUNC(gethostbyname_r, [
3026 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3027 AC_MSG_CHECKING([gethostbyname_r with 6 args])
3029 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
3034 struct hostent *he, *res;
3039 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
3041 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3042 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
3043 [Define this if you have the 6-arg version of gethostbyname_r().])
3047 AC_MSG_CHECKING([gethostbyname_r with 5 args])
3057 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
3059 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3060 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
3061 [Define this if you have the 5-arg version of gethostbyname_r().])
3065 AC_MSG_CHECKING([gethostbyname_r with 3 args])
3071 struct hostent_data data;
3073 (void) gethostbyname_r(name, he, &data);
3075 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3076 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
3077 [Define this if you have the 3-arg version of gethostbyname_r().])
3086 AC_CHECK_FUNCS(gethostbyname)
3088 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
3089 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
3090 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
3091 AC_SUBST(HAVE_GETHOSTBYNAME_R)
3092 AC_SUBST(HAVE_GETHOSTBYNAME)
3094 # checks for system services
3097 # Linux requires this for correct f.p. operations
3098 AC_CHECK_FUNC(__fpu_control,
3100 [AC_CHECK_LIB(ieee, __fpu_control)
3103 # Check for --with-fpectl
3104 AC_MSG_CHECKING(for --with-fpectl)
3106 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
3108 if test "$withval" != no
3110 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
3111 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
3113 else AC_MSG_RESULT(no)
3115 [AC_MSG_RESULT(no)])
3117 # check for --with-libm=...
3119 case $ac_sys_system in
3124 AC_MSG_CHECKING(for --with-libm=STRING)
3126 AC_HELP_STRING(--with-libm=STRING, math library),
3128 if test "$withval" = no
3130 AC_MSG_RESULT(force LIBM empty)
3131 elif test "$withval" != yes
3133 AC_MSG_RESULT(set LIBM="$withval")
3134 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
3136 [AC_MSG_RESULT(default LIBM="$LIBM")])
3138 # check for --with-libc=...
3140 AC_MSG_CHECKING(for --with-libc=STRING)
3142 AC_HELP_STRING(--with-libc=STRING, C library),
3144 if test "$withval" = no
3146 AC_MSG_RESULT(force LIBC empty)
3147 elif test "$withval" != yes
3149 AC_MSG_RESULT(set LIBC="$withval")
3150 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
3152 [AC_MSG_RESULT(default LIBC="$LIBC")])
3154 # ************************************
3155 # * Check for mathematical functions *
3156 # ************************************
3161 # Detect whether system arithmetic is subject to x87-style double
3162 # rounding issues. The result of this test has little meaning on non
3163 # IEEE 754 platforms. On IEEE 754, test should return 1 if rounding
3164 # mode is round-to-nearest and double rounding issues are present, and
3165 # 0 otherwise. See http://bugs.python.org/issue2937 for more info.
3166 AC_MSG_CHECKING(for x87-style double rounding)
3167 AC_CACHE_VAL(ac_cv_x87_double_rounding, [
3172 volatile double x, y, z;
3173 /* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */
3174 x = 0.99999999999999989; /* 1-2**-53 */
3178 /* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
3184 /* both tests show evidence of double rounding */
3188 ac_cv_x87_double_rounding=no,
3189 ac_cv_x87_double_rounding=yes,
3190 ac_cv_x87_double_rounding=no)])
3191 AC_MSG_RESULT($ac_cv_x87_double_rounding)
3192 if test "$ac_cv_x87_double_rounding" = yes
3194 AC_DEFINE(X87_DOUBLE_ROUNDING, 1,
3195 [Define if arithmetic is subject to x87-style double rounding issue])
3199 # On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
3200 # -0. on some architectures.
3201 AC_MSG_CHECKING(whether tanh preserves the sign of zero)
3202 AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
3207 /* return 0 if either negative zeros don't exist
3208 on this platform or if negative zeros exist
3209 and tanh(-0.) == -0. */
3210 if (atan2(0., -1.) == atan2(-0., -1.) ||
3211 atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
3215 ac_cv_tanh_preserves_zero_sign=yes,
3216 ac_cv_tanh_preserves_zero_sign=no,
3217 ac_cv_tanh_preserves_zero_sign=no)])
3218 AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
3219 if test "$ac_cv_tanh_preserves_zero_sign" = yes
3221 AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
3222 [Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
3225 AC_CHECK_FUNCS([acosh asinh atanh copysign expm1 finite hypot log1p])
3226 AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]])
3230 # determine what size digit to use for Python's longs
3231 AC_MSG_CHECKING([digit size for Python's longs])
3232 AC_ARG_ENABLE(big-digits,
3233 AC_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
3234 [case $enable_big_digits in
3236 enable_big_digits=30 ;;
3238 enable_big_digits=15 ;;
3242 AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
3244 AC_MSG_RESULT($enable_big_digits)
3245 AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits])
3247 [AC_MSG_RESULT(no value specified)])
3250 AC_CHECK_HEADER(wchar.h, [
3251 AC_DEFINE(HAVE_WCHAR_H, 1,
3252 [Define if the compiler provides a wchar.h header file.])
3258 # determine wchar_t size
3259 if test "$wchar_h" = yes
3261 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
3264 AC_MSG_CHECKING(for UCS-4 tcl)
3268 #if TCL_UTF_MAX != 6
3269 # error "NOT UCS4_TCL"
3271 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
3274 AC_MSG_RESULT($have_ucs4_tcl)
3276 # check whether wchar_t is signed or not
3277 if test "$wchar_h" = yes
3279 # check whether wchar_t is signed or not
3280 AC_MSG_CHECKING(whether wchar_t is signed)
3281 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
3286 /* Success: exit code 0 */
3287 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
3290 ac_cv_wchar_t_signed=yes,
3291 ac_cv_wchar_t_signed=no,
3292 ac_cv_wchar_t_signed=yes)])
3293 AC_MSG_RESULT($ac_cv_wchar_t_signed)
3296 AC_MSG_CHECKING(what type to use for unicode)
3297 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
3298 AC_ARG_ENABLE(unicode,
3299 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
3301 [enable_unicode=yes])
3303 if test $enable_unicode = yes
3305 # Without any arguments, Py_UNICODE defaults to two-byte mode
3306 case "$have_ucs4_tcl" in
3307 yes) enable_unicode="ucs4"
3309 *) enable_unicode="ucs2"
3314 AH_TEMPLATE(Py_UNICODE_SIZE,
3315 [Define as the size of the unicode type.])
3316 case "$enable_unicode" in
3317 ucs2) unicode_size="2"
3318 AC_DEFINE(Py_UNICODE_SIZE,2)
3320 ucs4) unicode_size="4"
3321 AC_DEFINE(Py_UNICODE_SIZE,4)
3325 AH_TEMPLATE(PY_UNICODE_TYPE,
3326 [Define as the integral type used for Unicode representation.])
3328 AC_SUBST(UNICODE_OBJS)
3329 if test "$enable_unicode" = "no"
3332 AC_MSG_RESULT(not used)
3334 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
3335 AC_DEFINE(Py_USING_UNICODE, 1,
3336 [Define if you want to have a Unicode type.])
3338 # wchar_t is only usable if it maps to an unsigned type
3339 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3340 -a "$ac_cv_wchar_t_signed" = "no"
3342 PY_UNICODE_TYPE="wchar_t"
3343 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3344 [Define if you have a useable wchar_t type defined in wchar.h; useable
3345 means wchar_t must be an unsigned type with at least 16 bits. (see
3346 Include/unicodeobject.h).])
3347 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3348 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3350 PY_UNICODE_TYPE="unsigned short"
3351 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3352 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3354 PY_UNICODE_TYPE="unsigned long"
3355 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3357 PY_UNICODE_TYPE="no type found"
3359 AC_MSG_RESULT($PY_UNICODE_TYPE)
3362 # check for endianness
3365 # Check whether right shifting a negative integer extends the sign bit
3366 # or fills with zeros (like the Cray J90, according to Tim Peters).
3367 AC_MSG_CHECKING(whether right shift extends the sign bit)
3368 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3372 exit(((-1)>>3 == -1) ? 0 : 1);
3375 ac_cv_rshift_extends_sign=yes,
3376 ac_cv_rshift_extends_sign=no,
3377 ac_cv_rshift_extends_sign=yes)])
3378 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3379 if test "$ac_cv_rshift_extends_sign" = no
3381 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3382 [Define if i>>j for signed int i does not extend the sign bit
3386 # check for getc_unlocked and related locking functions
3387 AC_MSG_CHECKING(for getc_unlocked() and friends)
3388 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3389 AC_TRY_LINK([#include <stdio.h>],[
3390 FILE *f = fopen("/dev/null", "r");
3394 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3395 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3396 if test "$ac_cv_have_getc_unlocked" = yes
3398 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3399 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3402 # check where readline lives
3403 # save the value of LIBS so we don't actually link Python with readline
3404 LIBS_no_readline=$LIBS
3406 # On some systems we need to link readline to a termcap compatible
3407 # library. NOTE: Keep the precedence of listed libraries synchronised
3409 py_cv_lib_readline=no
3410 AC_MSG_CHECKING([how to link readline libs])
3411 for py_libtermcap in "" ncursesw ncurses curses termcap; do
3412 if test -z "$py_libtermcap"; then
3413 READLINE_LIBS="-lreadline"
3415 READLINE_LIBS="-lreadline -l$py_libtermcap"
3417 LIBS="$READLINE_LIBS $LIBS_no_readline"
3419 [AC_LANG_CALL([],[readline])],
3420 [py_cv_lib_readline=yes])
3421 if test $py_cv_lib_readline = yes; then
3425 # Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
3426 #AC_SUBST([READLINE_LIBS])
3427 if test $py_cv_lib_readline = no; then
3428 AC_MSG_RESULT([none])
3430 AC_MSG_RESULT([$READLINE_LIBS])
3431 AC_DEFINE(HAVE_LIBREADLINE, 1,
3432 [Define if you have the readline library (-lreadline).])
3435 # check for readline 2.1
3436 AC_CHECK_LIB(readline, rl_callback_handler_install,
3437 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3438 [Define if you have readline 2.1]), ,$READLINE_LIBS)
3440 # check for readline 2.2
3441 AC_TRY_CPP([#include <readline/readline.h>],
3442 have_readline=yes, have_readline=no)
3443 if test $have_readline = yes
3445 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3446 [readline/readline.h],
3447 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3448 [Define if you have readline 2.2]), )
3451 # check for readline 4.0
3452 AC_CHECK_LIB(readline, rl_pre_input_hook,
3453 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3454 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3457 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
3458 AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
3459 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3461 # check for readline 4.2
3462 AC_CHECK_LIB(readline, rl_completion_matches,
3463 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3464 [Define if you have readline 4.2]), ,$READLINE_LIBS)
3466 # also in readline 4.2
3467 AC_TRY_CPP([#include <readline/readline.h>],
3468 have_readline=yes, have_readline=no)
3469 if test $have_readline = yes
3471 AC_EGREP_HEADER([extern int rl_catch_signals;],
3472 [readline/readline.h],
3473 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3474 [Define if you can turn off readline's signal handling.]), )
3477 # End of readline checks: restore LIBS
3478 LIBS=$LIBS_no_readline
3480 AC_MSG_CHECKING(for broken nice())
3481 AC_CACHE_VAL(ac_cv_broken_nice, [
3486 if (val1 != -1 && val1 == nice(2))
3491 ac_cv_broken_nice=yes,
3492 ac_cv_broken_nice=no,
3493 ac_cv_broken_nice=no)])
3494 AC_MSG_RESULT($ac_cv_broken_nice)
3495 if test "$ac_cv_broken_nice" = yes
3497 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3498 [Define if nice() returns success/failure instead of the new priority.])
3501 AC_MSG_CHECKING(for broken poll())
3507 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3511 int poll_test = poll (&poll_struct, 1, 0);
3517 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3527 ac_cv_broken_poll=yes,
3528 ac_cv_broken_poll=no,
3529 ac_cv_broken_poll=no)
3530 AC_MSG_RESULT($ac_cv_broken_poll)
3531 if test "$ac_cv_broken_poll" = yes
3533 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3534 [Define if poll() sets errno on invalid file descriptors.])
3537 # Before we can test tzset, we need to check if struct tm has a tm_zone
3538 # (which is not required by ISO C or UNIX spec) and/or if we support
3542 # check tzset(3) exists and works like we expect it to
3543 AC_MSG_CHECKING(for working tzset())
3544 AC_CACHE_VAL(ac_cv_working_tzset, [
3551 extern char *tzname[];
3556 /* Note that we need to ensure that not only does tzset(3)
3557 do 'something' with localtime, but it works as documented
3558 in the library reference and as expected by the test suite.
3559 This includes making sure that tzname is set properly if
3560 tm->tm_zone does not exist since it is the alternative way
3561 of getting timezone info.
3563 Red Hat 6.2 doesn't understand the southern hemisphere
3564 after New Year's Day.
3567 time_t groundhogday = 1044144000; /* GMT-based */
3568 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3572 if (localtime(&groundhogday)->tm_hour != 0)
3575 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3576 if (strcmp(tzname[0], "UTC") ||
3577 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3581 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3583 if (localtime(&groundhogday)->tm_hour != 19)
3586 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3590 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3592 if (localtime(&groundhogday)->tm_hour != 11)
3595 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3599 #if HAVE_STRUCT_TM_TM_ZONE
3600 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3602 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3609 ac_cv_working_tzset=yes,
3610 ac_cv_working_tzset=no,
3611 ac_cv_working_tzset=no)])
3612 AC_MSG_RESULT($ac_cv_working_tzset)
3613 if test "$ac_cv_working_tzset" = yes
3615 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3616 [Define if tzset() actually switches the local timezone in a meaningful way.])
3619 # Look for subsecond timestamps in struct stat
3620 AC_MSG_CHECKING(for tv_nsec in struct stat)
3621 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3622 AC_TRY_COMPILE([#include <sys/stat.h>], [
3624 st.st_mtim.tv_nsec = 1;
3626 ac_cv_stat_tv_nsec=yes,
3627 ac_cv_stat_tv_nsec=no,
3628 ac_cv_stat_tv_nsec=no))
3629 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3630 if test "$ac_cv_stat_tv_nsec" = yes
3632 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3633 [Define if you have struct stat.st_mtim.tv_nsec])
3636 # Look for BSD style subsecond timestamps in struct stat
3637 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3638 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3639 AC_TRY_COMPILE([#include <sys/stat.h>], [
3641 st.st_mtimespec.tv_nsec = 1;
3643 ac_cv_stat_tv_nsec2=yes,
3644 ac_cv_stat_tv_nsec2=no,
3645 ac_cv_stat_tv_nsec2=no))
3646 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3647 if test "$ac_cv_stat_tv_nsec2" = yes
3649 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3650 [Define if you have struct stat.st_mtimensec])
3653 # On HP/UX 11.0, mvwdelch is a block with a return statement
3654 AC_MSG_CHECKING(whether mvwdelch is an expression)
3655 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3656 AC_TRY_COMPILE([#include <curses.h>], [
3658 rtn = mvwdelch(0,0,0);
3659 ], ac_cv_mvwdelch_is_expression=yes,
3660 ac_cv_mvwdelch_is_expression=no,
3661 ac_cv_mvwdelch_is_expression=yes))
3662 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3664 if test "$ac_cv_mvwdelch_is_expression" = yes
3666 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3667 [Define if mvwdelch in curses.h is an expression.])
3670 AC_MSG_CHECKING(whether WINDOW has _flags)
3671 AC_CACHE_VAL(ac_cv_window_has_flags,
3672 AC_TRY_COMPILE([#include <curses.h>], [
3675 ], ac_cv_window_has_flags=yes,
3676 ac_cv_window_has_flags=no,
3677 ac_cv_window_has_flags=no))
3678 AC_MSG_RESULT($ac_cv_window_has_flags)
3681 if test "$ac_cv_window_has_flags" = yes
3683 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3684 [Define if WINDOW in curses.h offers a field _flags.])
3687 AC_MSG_CHECKING(for is_term_resized)
3688 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3689 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3694 AC_MSG_CHECKING(for resize_term)
3695 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3696 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3701 AC_MSG_CHECKING(for resizeterm)
3702 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3703 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3708 AC_MSG_CHECKING(for /dev/ptmx)
3710 if test -r /dev/ptmx
3713 AC_DEFINE(HAVE_DEV_PTMX, 1,
3714 [Define if we have /dev/ptmx.])
3719 AC_MSG_CHECKING(for /dev/ptc)
3724 AC_DEFINE(HAVE_DEV_PTC, 1,
3725 [Define if we have /dev/ptc.])
3730 AC_MSG_CHECKING(for %zd printf() format support)
3731 AC_TRY_RUN([#include <stdio.h>
3735 #ifdef HAVE_SYS_TYPES_H
3736 #include <sys/types.h>
3740 typedef ssize_t Py_ssize_t;
3741 #elif SIZEOF_VOID_P == SIZEOF_LONG
3742 typedef long Py_ssize_t;
3744 typedef int Py_ssize_t;
3751 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3754 if (strcmp(buffer, "123"))
3757 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3760 if (strcmp(buffer, "-123"))
3766 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3769 AC_CHECK_TYPE(socklen_t,,
3770 AC_DEFINE(socklen_t,int,
3771 Define to `int' if <sys/socket.h> does not define.),[
3772 #ifdef HAVE_SYS_TYPES_H
3773 #include <sys/types.h>
3775 #ifdef HAVE_SYS_SOCKET_H
3776 #include <sys/socket.h>
3780 AC_SUBST(THREADHEADERS)
3782 for h in `(cd $srcdir;echo Python/thread_*.h)`
3784 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3788 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3789 AC_MSG_CHECKING(for build directories)
3790 for dir in $SRCDIRS; do
3791 if test ! -d $dir; then
3797 # generate output files
3798 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3801 echo "creating Modules/Setup"
3802 if test ! -f Modules/Setup
3804 cp $srcdir/Modules/Setup.dist Modules/Setup
3807 echo "creating Modules/Setup.local"
3808 if test ! -f Modules/Setup.local
3810 echo "# Edit this file for local setup changes" >Modules/Setup.local
3813 echo "creating Makefile"
3814 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3815 -s Modules Modules/Setup.config \
3816 Modules/Setup.local Modules/Setup
3818 case $ac_sys_system in
3822 Support for BeOS is deprecated as of Python 2.6.
3823 See PEP 11 for the gory details.