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, 3.1)
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/Resources/framework/Info.plist)
184 AC_CONFIG_FILES(Mac/Resources/app/Info.plist)
188 PYTHONFRAMEWORKDIR=no-framework
189 PYTHONFRAMEWORKPREFIX=
190 PYTHONFRAMEWORKINSTALLDIR=
191 FRAMEWORKINSTALLFIRST=
192 FRAMEWORKINSTALLLAST=
193 FRAMEWORKALTINSTALLFIRST=
194 FRAMEWORKALTINSTALLLAST=
195 if test "x${prefix}" = "xNONE" ; then
196 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
198 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
202 if test "$UNIVERSAL_ARCHS" = "all"
204 FRAMEWORKINSTALLLAST=update4wayuniversal
205 FRAMEWORKALTINSTALLLAST=update4wayuniversal
208 AC_SUBST(PYTHONFRAMEWORK)
209 AC_SUBST(PYTHONFRAMEWORKIDENTIFIER)
210 AC_SUBST(PYTHONFRAMEWORKDIR)
211 AC_SUBST(PYTHONFRAMEWORKPREFIX)
212 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
213 AC_SUBST(FRAMEWORKINSTALLFIRST)
214 AC_SUBST(FRAMEWORKINSTALLLAST)
215 AC_SUBST(FRAMEWORKALTINSTALLFIRST)
216 AC_SUBST(FRAMEWORKALTINSTALLLAST)
217 AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX)
220 ## AC_HELP_STRING(--with-dyld,
221 ## Use (OpenStep|Rhapsody) dynamic linker))
223 # Set name for machine-dependent library files
225 AC_MSG_CHECKING(MACHDEP)
226 if test -z "$MACHDEP"
228 ac_sys_system=`uname -s`
229 if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64" \
230 -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
231 ac_sys_release=`uname -v`
233 ac_sys_release=`uname -r`
235 ac_md_system=`echo $ac_sys_system |
236 tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
237 ac_md_release=`echo $ac_sys_release |
238 tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
239 MACHDEP="$ac_md_system$ac_md_release"
242 cygwin*) MACHDEP="cygwin";;
243 darwin*) MACHDEP="darwin";;
244 atheos*) MACHDEP="atheos";;
245 irix646) MACHDEP="irix6";;
246 '') MACHDEP="unknown";;
250 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
251 # disable features if it is defined, without any means to access these
252 # features as extensions. For these systems, we skip the definition of
253 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
254 # some feature, make sure there is no alternative way to access this
255 # feature. Also, when using wildcards, make sure you have verified the
256 # need for not defining _XOPEN_SOURCE on all systems matching the
257 # wildcard, and that the wildcard does not include future systems
258 # (which may remove their limitations).
259 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
260 case $ac_sys_system/$ac_sys_release in
261 # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
262 # even though select is a POSIX function. Reported by J. Ribbens.
263 # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
264 OpenBSD/2.* | OpenBSD/3.@<:@0123456789@:>@ | OpenBSD/4.@<:@0123@:>@)
265 define_xopen_source=no
266 # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
267 # also defined. This can be overridden by defining _BSD_SOURCE
268 # As this has a different meaning on Linux, only define it on OpenBSD
269 AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
271 # Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
272 # _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
274 NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6@<:@A-S@:>@)
275 define_xopen_source=no;;
276 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
277 # of union __?sigval. Reported by Stuart Bishop.
279 define_xopen_source=no;;
280 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
281 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
282 # Reconfirmed for 7.1.4 by Martin v. Loewis.
283 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
284 define_xopen_source=no;;
285 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
286 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
288 define_xopen_source=no;;
289 # On FreeBSD 4, the math functions C89 does not cover are never defined
290 # with _XOPEN_SOURCE and __BSD_VISIBLE does not re-enable them.
292 define_xopen_source=no;;
293 # On MacOS X 10.2, a bug in ncurses.h means that it craps out if
294 # _XOPEN_EXTENDED_SOURCE is defined. Apparently, this is fixed in 10.3, which
295 # identifies itself as Darwin/7.*
296 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
297 # disables platform specific features beyond repair.
298 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
299 # has no effect, don't bother defining them
300 Darwin/@<:@6789@:>@.*)
301 define_xopen_source=no;;
302 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
303 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
304 # or has another value. By not (re)defining it, the defaults come in place.
306 define_xopen_source=no;;
308 if test `uname -r` -eq 1; then
309 define_xopen_source=no
312 # On QNX 6.3.2, defining _XOPEN_SOURCE prevents netdb.h from
313 # defining NI_NUMERICHOST.
315 define_xopen_source=no
320 if test $define_xopen_source = yes
322 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
323 # defined precisely as g++ defines it
324 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
326 case $ac_sys_system/$ac_sys_release in
327 SunOS/5.8|SunOS/5.9|SunOS/5.10)
328 AC_DEFINE(_XOPEN_SOURCE, 500,
329 Define to the level of X/Open that your system supports)
332 AC_DEFINE(_XOPEN_SOURCE, 600,
333 Define to the level of X/Open that your system supports)
337 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
338 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
339 # several APIs are not declared. Since this is also needed in some
340 # cases for HP-UX, we define it globally.
341 # except for Solaris 10, where it must not be defined,
342 # as it implies XPG4.2
343 case $ac_sys_system/$ac_sys_release in
347 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
348 Define to activate Unix95-and-earlier features)
352 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
357 # SGI compilers allow the specification of the both the ABI and the
358 # ISA on the command line. Depending on the values of these switches,
359 # different and often incompatable code will be generated.
361 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
362 # thus supply support for various ABI/ISA combinations. The MACHDEP
363 # variable is also adjusted.
366 if test ! -z "$SGI_ABI"
369 LDFLAGS="$SGI_ABI $LDFLAGS"
370 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
372 AC_MSG_RESULT($MACHDEP)
374 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
375 # it may influence the way we can build extensions, so distutils
377 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
378 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
379 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
380 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
382 AC_MSG_CHECKING(machine type as reported by uname -m)
383 ac_sys_machine=`uname -m`
384 AC_MSG_RESULT($ac_sys_machine)
386 # checks for alternative programs
388 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
389 # for debug/optimization stuff. BASECFLAGS is for flags that are required
390 # just to get things to compile and link. Users are free to override OPT
391 # when running configure or make. The build should not break if they do.
392 # BASECFLAGS should generally not be messed with, however.
394 # XXX shouldn't some/most/all of this code be merged with the stuff later
395 # on that fiddles with OPT and BASECFLAGS?
396 AC_MSG_CHECKING(for --without-gcc)
398 AC_HELP_STRING(--without-gcc,never use gcc),
406 without_gcc=$withval;;
408 case $ac_sys_system in
416 AC_MSG_RESULT($without_gcc)
418 # If the user switches compilers, we can't believe the cache
419 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
421 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
422 (it is also a good idea to do 'make clean' before compiling)])
429 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
430 AC_ARG_WITH(cxx_main,
431 AC_HELP_STRING([--with-cxx-main=<compiler>],
432 [compile main() and link python executable with C++ compiler]),
438 yes) with_cxx_main=yes
450 AC_MSG_RESULT($with_cxx_main)
456 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
457 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
459 if test "$CXX" = "notfound"
466 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
467 if test "$CXX" = "notfound"
472 if test "$preset_cxx" != "$CXX"
476 By default, distutils will build C++ extension modules with "$CXX".
477 If this is not intended, then set CXX on the configure command line.
482 # checks for UNIX variants that set C preprocessor variables
485 # Check for unsupported systems
486 case $ac_sys_system/$ac_sys_release in
488 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
489 echo See README for details.
494 AC_MSG_CHECKING(for --with-suffix)
496 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
503 AC_MSG_RESULT($EXEEXT)
505 # Test whether we're running on a non-case-sensitive system, in which
506 # case we give a warning if no ext is given
507 AC_SUBST(BUILDEXEEXT)
508 AC_MSG_CHECKING(for case-insensitive build directory)
509 if test ! -d CaseSensitiveTestDir; then
510 mkdir CaseSensitiveTestDir
513 if test -d casesensitivetestdir
521 rmdir CaseSensitiveTestDir
526 gcc) CC="$CC -D_HAVE_BSDI";;
530 case $ac_sys_system in
533 cc|*/cc) CC="$CC -Ae";;
537 cc) CC="$CC -Wl,-Bexport";;
540 # Some functions have a prototype only with that define, e.g. confstr
541 AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
547 AC_MSG_CHECKING(LIBRARY)
548 if test -z "$LIBRARY"
550 LIBRARY='libpython$(VERSION).a'
552 AC_MSG_RESULT($LIBRARY)
554 # LDLIBRARY is the name of the library to link against (as opposed to the
555 # name of the library into which to insert object files). BLDLIBRARY is also
556 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
557 # is blank as the main program is not linked directly against LDLIBRARY.
558 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
559 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
560 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
561 # DLLLIBRARY is the shared (i.e., DLL) library.
563 # RUNSHARED is used to run shared python without installed libraries
565 # INSTSONAME is the name of the shared library that will be use to install
566 # on the system - some systems like version suffix, others don't
570 AC_SUBST(LDLIBRARYDIR)
574 BLDLIBRARY='$(LDLIBRARY)'
575 INSTSONAME='$(LDLIBRARY)'
580 # LINKCC is the command that links the python executable -- default is $(CC).
581 # If CXX is set, and if it is needed to link a main function that was
582 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
583 # python might then depend on the C++ runtime
584 # This is altered for AIX in order to build the export list before
587 AC_MSG_CHECKING(LINKCC)
590 LINKCC='$(PURIFY) $(MAINCC)'
591 case $ac_sys_system in
594 if test $ac_sys_release -ge 5 -o \
595 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
598 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
600 LINKCC="$LINKCC -L/usr/lib/ia64l64";;
602 # qcc must be used because the other compilers do not
607 AC_MSG_RESULT($LINKCC)
609 AC_MSG_CHECKING(for --enable-shared)
610 AC_ARG_ENABLE(shared,
611 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
613 if test -z "$enable_shared"
615 case $ac_sys_system in
617 enable_shared="yes";;
622 AC_MSG_RESULT($enable_shared)
624 AC_MSG_CHECKING(for --enable-profiling)
625 AC_ARG_ENABLE(profiling,
626 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
629 AC_TRY_RUN([int main() { return 0; }],
630 ac_enable_profiling="yes",
631 ac_enable_profiling="no",
632 ac_enable_profiling="no")
634 AC_MSG_RESULT($ac_enable_profiling)
636 case "$ac_enable_profiling" in
638 BASECFLAGS="-pg $BASECFLAGS"
639 LDFLAGS="-pg $LDFLAGS"
643 AC_MSG_CHECKING(LDLIBRARY)
645 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
646 # library that we build, but we do not want to link against it (we
647 # will find it with a -framework option). For this reason there is an
648 # extra variable BLDLIBRARY against which Python and the extension
649 # modules are linked, BLDLIBRARY. This is normally the same as
650 # LDLIBRARY, but empty for MacOSX framework builds.
651 if test "$enable_framework"
653 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
654 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
657 BLDLIBRARY='$(LDLIBRARY)'
660 # Other platforms follow
661 if test $enable_shared = "yes"; then
662 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
663 case $ac_sys_system in
665 LDLIBRARY='libpython$(VERSION).dll.a'
666 DLLLIBRARY='libpython$(VERSION).dll'
669 LDLIBRARY='libpython$(VERSION).so'
670 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
671 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
672 INSTSONAME="$LDLIBRARY".$SOVERSION
674 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
675 LDLIBRARY='libpython$(VERSION).so'
676 BLDLIBRARY='-L. -lpython$(VERSION)'
677 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
678 case $ac_sys_system in
680 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
683 INSTSONAME="$LDLIBRARY".$SOVERSION
688 LDLIBRARY='libpython$(VERSION).so'
691 LDLIBRARY='libpython$(VERSION).sl'
694 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
695 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
698 LDLIBRARY='libpython$(VERSION).so'
699 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
700 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
703 LDLIBRARY='libpython$(VERSION).so'
704 BLDLIBRARY='-L. -lpython$(VERSION)'
705 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
708 LDLIBRARY='libpython$(VERSION).dylib'
709 BLDLIBRARY='-L. -lpython$(VERSION)'
710 RUNSHARED='DYLD_LIBRARY_PATH=`pwd`:${DYLD_LIBRARY_PATH}'
714 else # shared is disabled
715 case $ac_sys_system in
717 BLDLIBRARY='$(LIBRARY)'
718 LDLIBRARY='libpython$(VERSION).dll.a'
723 AC_MSG_RESULT($LDLIBRARY)
727 AC_CHECK_PROGS(AR, ar aal, ar)
730 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
731 if test $SVNVERSION = found
733 SVNVERSION="svnversion \$(srcdir)"
735 SVNVERSION="echo exported"
740 # install -d does not work on BSDI or HP-UX
741 if test -z "$INSTALL"
743 INSTALL="${srcdir}/install-sh -c"
748 # Not every filesystem supports hard links
750 if test -z "$LN" ; then
751 case $ac_sys_system in
752 CYGWIN*) LN="ln -s";;
753 atheos*) LN="ln -s";;
758 # Check for --with-pydebug
759 AC_MSG_CHECKING(for --with-pydebug)
761 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
763 if test "$withval" != no
765 AC_DEFINE(Py_DEBUG, 1,
766 [Define if you want to build an interpreter with many run-time checks.])
769 else AC_MSG_RESULT(no); Py_DEBUG='false'
773 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
774 # merged with this chunk of code?
776 # Optimizer/debugger flags
777 # ------------------------
778 # (The following bit of code is complicated enough - please keep things
779 # indented properly. Just pretend you're editing Python code. ;-)
781 # There are two parallel sets of case statements below, one that checks to
782 # see if OPT was set and one that does BASECFLAGS setting based upon
783 # compiler and platform. BASECFLAGS tweaks need to be made even if the
786 # tweak OPT based on compiler and platform, only if the user didn't set
787 # it on the command line
793 if test "$CC" != 'g++' ; then
794 STRICT_PROTO="-Wstrict-prototypes"
796 # For gcc 4.x we need to use -fwrapv so lets check if its supported
797 if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
800 case $ac_cv_prog_cc_g in
802 if test "$Py_DEBUG" = 'true' ; then
803 # Optimization messes up debuggers, so turn it off for
805 OPT="-g -Wall $STRICT_PROTO"
807 OPT="-g $WRAP -O3 -Wall $STRICT_PROTO"
811 OPT="-O3 -Wall $STRICT_PROTO"
814 case $ac_sys_system in
815 SCO_SV*) OPT="$OPT -m486 -DSCO5"
825 # The current (beta) Monterey compiler dies with optimizations
826 # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
827 case $ac_sys_system in
837 # The -arch flags for universal builds on OSX
838 UNIVERSAL_ARCH_FLAGS=
839 AC_SUBST(UNIVERSAL_ARCH_FLAGS)
841 # tweak BASECFLAGS based on compiler and platform
844 # Python violates C99 rules, by casting between incompatible
845 # pointer types. GCC may generate bad code as a result of that,
846 # so use -fno-strict-aliasing if supported.
847 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
849 CC="$CC -fno-strict-aliasing"
850 AC_TRY_RUN([int main() { return 0; }],
851 ac_cv_no_strict_aliasing_ok=yes,
852 ac_cv_no_strict_aliasing_ok=no,
853 ac_cv_no_strict_aliasing_ok=no)
855 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
856 if test $ac_cv_no_strict_aliasing_ok = yes
858 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
861 # if using gcc on alpha, use -mieee to get (near) full IEEE 754
862 # support. Without this, treatment of subnormals doesn't follow
864 case $ac_sys_machine in
866 BASECFLAGS="$BASECFLAGS -mieee"
870 case $ac_sys_system in
872 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
874 # is there any other compiler on Darwin besides gcc?
876 # -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
877 # used to be here, but non-Apple gcc doesn't accept them.
880 if test "${enable_universalsdk}"; then
881 UNIVERSAL_ARCH_FLAGS=""
882 if test "$UNIVERSAL_ARCHS" = "32-bit" ; then
883 UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386"
886 elif test "$UNIVERSAL_ARCHS" = "64-bit" ; then
887 UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64"
889 elif test "$UNIVERSAL_ARCHS" = "all" ; then
890 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64"
891 ARCH_RUN_32BIT="arch -i386 -ppc"
894 AC_MSG_ERROR([proper usage is --with-universalarch=32-bit|64-bit|all])
899 BASECFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
900 tgt=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
901 if test "${UNIVERSALSDK}" != "/" -a "${tgt}" '>' '10.4' ; then
902 CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
906 # Calculate the right deployment target for this build.
908 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
909 if test ${cur_target} '>' 10.2; then
912 if test "${UNIVERSAL_ARCHS}" = "all"; then
913 # Ensure that the default platform for a 4-way
914 # universal build is OSX 10.5, that's the first
915 # OS release where 4-way builds make sense.
918 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
920 # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
921 # environment with a value that is the same as what we'll use
922 # in the Makefile to ensure that we'll get the same compiler
923 # environment during configure and build time.
924 MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
925 export MACOSX_DEPLOYMENT_TARGET
926 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
930 BASECFLAGS="$BASECFLAGS -mieee"
936 case $ac_sys_system in
938 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
941 BASECFLAGS="$BASECFLAGS -ieee -std"
944 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
950 if test "$Py_DEBUG" = 'true'; then
956 if test "$ac_arch_flags"
958 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
961 # disable check for icc since it seems to pass, but generates a warning
964 ac_cv_opt_olimit_ok=no
967 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
968 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
970 CC="$CC -OPT:Olimit=0"
971 AC_TRY_RUN([int main() { return 0; }],
972 ac_cv_opt_olimit_ok=yes,
973 ac_cv_opt_olimit_ok=no,
974 ac_cv_opt_olimit_ok=no)
976 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
977 if test $ac_cv_opt_olimit_ok = yes; then
978 case $ac_sys_system in
979 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
980 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
985 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
989 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
990 AC_CACHE_VAL(ac_cv_olimit_ok,
992 CC="$CC -Olimit 1500"
993 AC_TRY_RUN([int main() { return 0; }],
998 AC_MSG_RESULT($ac_cv_olimit_ok)
999 if test $ac_cv_olimit_ok = yes; then
1000 BASECFLAGS="$BASECFLAGS -Olimit 1500"
1004 # Check whether GCC supports PyArg_ParseTuple format
1005 if test "$GCC" = "yes"
1007 AC_MSG_CHECKING(whether gcc supports ParseTuple __format__)
1009 CFLAGS="$CFLAGS -Werror"
1011 void f(char*,...)__attribute((format(PyArg_ParseTuple, 1, 2)));
1013 AC_DEFINE(HAVE_ATTRIBUTE_FORMAT_PARSETUPLE, 1, [Define if GCC supports __attribute__((format(PyArg_ParseTuple, 2, 3)))])
1020 # On some compilers, pthreads are available without further options
1021 # (e.g. MacOS X). On some of these systems, the compiler will not
1022 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
1023 # So we have to see first whether pthreads are available without
1024 # options before we can check whether -Kpthread improves anything.
1025 AC_MSG_CHECKING(whether pthreads are available without options)
1026 AC_CACHE_VAL(ac_cv_pthread_is_default,
1028 #include <pthread.h>
1030 void* routine(void* p){return NULL;}
1034 if(pthread_create(&p,NULL,routine,NULL)!=0)
1036 (void)pthread_detach(p);
1041 ac_cv_pthread_is_default=yes
1045 ac_cv_pthread_is_default=no,
1046 ac_cv_pthread_is_default=no)
1048 AC_MSG_RESULT($ac_cv_pthread_is_default)
1051 if test $ac_cv_pthread_is_default = yes
1055 # -Kpthread, if available, provides the right #defines
1056 # and linker options to make pthread_create available
1057 # Some compilers won't report that they do not support -Kpthread,
1058 # so we need to run a program to see whether it really made the
1059 # function available.
1060 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
1061 AC_CACHE_VAL(ac_cv_kpthread,
1065 #include <pthread.h>
1067 void* routine(void* p){return NULL;}
1071 if(pthread_create(&p,NULL,routine,NULL)!=0)
1073 (void)pthread_detach(p);
1081 AC_MSG_RESULT($ac_cv_kpthread)
1084 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
1086 # -Kthread, if available, provides the right #defines
1087 # and linker options to make pthread_create available
1088 # Some compilers won't report that they do not support -Kthread,
1089 # so we need to run a program to see whether it really made the
1090 # function available.
1091 AC_MSG_CHECKING(whether $CC accepts -Kthread)
1092 AC_CACHE_VAL(ac_cv_kthread,
1096 #include <pthread.h>
1098 void* routine(void* p){return NULL;}
1102 if(pthread_create(&p,NULL,routine,NULL)!=0)
1104 (void)pthread_detach(p);
1112 AC_MSG_RESULT($ac_cv_kthread)
1115 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
1117 # -pthread, if available, provides the right #defines
1118 # and linker options to make pthread_create available
1119 # Some compilers won't report that they do not support -pthread,
1120 # so we need to run a program to see whether it really made the
1121 # function available.
1122 AC_MSG_CHECKING(whether $CC accepts -pthread)
1123 AC_CACHE_VAL(ac_cv_thread,
1127 #include <pthread.h>
1129 void* routine(void* p){return NULL;}
1133 if(pthread_create(&p,NULL,routine,NULL)!=0)
1135 (void)pthread_detach(p);
1143 AC_MSG_RESULT($ac_cv_pthread)
1146 # If we have set a CC compiler flag for thread support then
1147 # check if it works for CXX, too.
1151 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1154 if test "$ac_cv_kpthread" = "yes"
1156 CXX="$CXX -Kpthread"
1157 ac_cv_cxx_thread=yes
1158 elif test "$ac_cv_kthread" = "yes"
1161 ac_cv_cxx_thread=yes
1162 elif test "$ac_cv_pthread" = "yes"
1165 ac_cv_cxx_thread=yes
1168 if test $ac_cv_cxx_thread = yes
1170 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1171 $CXX -c conftest.$ac_ext 2>&5
1172 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1173 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1175 ac_cv_cxx_thread=yes
1181 AC_MSG_RESULT($ac_cv_cxx_thread)
1185 dnl # check for ANSI or K&R ("traditional") preprocessor
1186 dnl AC_MSG_CHECKING(for C preprocessor type)
1187 dnl AC_TRY_COMPILE([
1188 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1190 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1191 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1192 dnl AC_MSG_RESULT($cpp_type)
1194 # checks for header files
1196 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1198 ieeefp.h io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
1199 shadow.h signal.h stdint.h stropts.h termios.h thread.h \
1201 sys/audioio.h sys/bsdtty.h sys/epoll.h sys/event.h sys/file.h sys/loadavg.h \
1202 sys/lock.h sys/mkdev.h sys/modem.h \
1203 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1204 sys/termio.h sys/time.h \
1205 sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1206 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1207 bluetooth/bluetooth.h linux/tipc.h)
1211 # On Solaris, term.h requires curses.h
1212 AC_CHECK_HEADERS(term.h,,,[
1213 #ifdef HAVE_CURSES_H
1218 # On Linux, netlink.h requires asm/types.h
1219 AC_CHECK_HEADERS(linux/netlink.h,,,[
1220 #ifdef HAVE_ASM_TYPES_H
1221 #include <asm/types.h>
1223 #ifdef HAVE_SYS_SOCKET_H
1224 #include <sys/socket.h>
1228 # checks for typedefs
1230 AC_MSG_CHECKING(for clock_t in time.h)
1231 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1232 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1234 AC_MSG_RESULT($was_it_defined)
1236 # Check whether using makedev requires defining _OSF_SOURCE
1237 AC_MSG_CHECKING(for makedev)
1238 AC_TRY_LINK([#include <sys/types.h> ],
1240 ac_cv_has_makedev=yes,
1241 ac_cv_has_makedev=no)
1242 if test "$ac_cv_has_makedev" = "no"; then
1243 # we didn't link, try if _OSF_SOURCE will allow us to link
1245 #define _OSF_SOURCE 1
1246 #include <sys/types.h>
1249 ac_cv_has_makedev=yes,
1250 ac_cv_has_makedev=no)
1251 if test "$ac_cv_has_makedev" = "yes"; then
1252 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1255 AC_MSG_RESULT($ac_cv_has_makedev)
1256 if test "$ac_cv_has_makedev" = "yes"; then
1257 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1260 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1261 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1262 # defined, but the compiler does not support pragma redefine_extname,
1263 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1264 # structures (such as rlimit64) without declaring them. As a
1265 # work-around, disable LFS on such configurations
1268 AC_MSG_CHECKING(Solaris LFS bug)
1270 #define _LARGEFILE_SOURCE 1
1271 #define _FILE_OFFSET_BITS 64
1272 #include <sys/resource.h>
1273 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1274 AC_MSG_RESULT($sol_lfs_bug)
1275 if test "$sol_lfs_bug" = "yes"; then
1279 if test "$use_lfs" = "yes"; then
1280 # Two defines needed to enable largefile support on various platforms
1281 # These may affect some typedefs
1282 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1283 [This must be defined on some systems to enable large file support.])
1284 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1285 [This must be set to 64 on some systems to enable large file support.])
1288 # Add some code to confdefs.h so that the test for off_t works on SCO
1289 cat >> confdefs.h <<\EOF
1295 # Type availability checks
1306 AC_CHECK_TYPE(ssize_t,
1307 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1309 # Sizes of various common basic types
1310 # ANSI C requires sizeof(char) == 1, so no need to check it
1311 AC_CHECK_SIZEOF(int, 4)
1312 AC_CHECK_SIZEOF(long, 4)
1313 AC_CHECK_SIZEOF(void *, 4)
1314 AC_CHECK_SIZEOF(short, 2)
1315 AC_CHECK_SIZEOF(float, 4)
1316 AC_CHECK_SIZEOF(double, 8)
1317 AC_CHECK_SIZEOF(fpos_t, 4)
1318 AC_CHECK_SIZEOF(size_t, 4)
1319 AC_CHECK_SIZEOF(pid_t, 4)
1321 AC_MSG_CHECKING(for long long support)
1323 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1324 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1327 AC_MSG_RESULT($have_long_long)
1328 if test "$have_long_long" = yes ; then
1329 AC_CHECK_SIZEOF(long long, 8)
1332 AC_MSG_CHECKING(for long double support)
1334 AC_TRY_COMPILE([], [long double x; x = (long double)0;], [
1335 AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define this if you have the type long double.])
1336 have_long_double=yes
1338 AC_MSG_RESULT($have_long_double)
1339 if test "$have_long_double" = yes ; then
1340 AC_CHECK_SIZEOF(long double, 16)
1344 AC_MSG_CHECKING(for _Bool support)
1346 AC_TRY_COMPILE([], [_Bool x; x = (_Bool)0;], [
1347 AC_DEFINE(HAVE_C99_BOOL, 1, [Define this if you have the type _Bool.])
1350 AC_MSG_RESULT($have_c99_bool)
1351 if test "$have_c99_bool" = yes ; then
1352 AC_CHECK_SIZEOF(_Bool, 1)
1355 AC_CHECK_TYPES(uintptr_t,
1356 [AC_CHECK_SIZEOF(uintptr_t, 4)],
1357 [], [#ifdef HAVE_STDINT_H
1362 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1363 AC_MSG_CHECKING(size of off_t)
1364 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1365 [AC_TRY_RUN([#include <stdio.h>
1366 #include <sys/types.h>
1369 FILE *f=fopen("conftestval", "w");
1371 fprintf(f, "%d\n", sizeof(off_t));
1374 ac_cv_sizeof_off_t=`cat conftestval`,
1375 ac_cv_sizeof_off_t=0,
1376 ac_cv_sizeof_off_t=4)
1378 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1379 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1380 [The number of bytes in an off_t.])
1382 AC_MSG_CHECKING(whether to enable large file support)
1383 if test "$have_long_long" = yes -a \
1384 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1385 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1386 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1387 [Defined to enable large file support when an off_t is bigger than a long
1388 and long long is available and at least as big as an off_t. You may need
1389 to add some flags for configuration and compilation to enable this mode.
1390 (For Solaris and Linux, the necessary defines are already defined.)])
1396 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1397 AC_MSG_CHECKING(size of time_t)
1398 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1399 [AC_TRY_RUN([#include <stdio.h>
1403 FILE *f=fopen("conftestval", "w");
1405 fprintf(f, "%d\n", sizeof(time_t));
1408 ac_cv_sizeof_time_t=`cat conftestval`,
1409 ac_cv_sizeof_time_t=0,
1410 ac_cv_sizeof_time_t=4)
1412 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1413 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1414 [The number of bytes in a time_t.])
1417 # if have pthread_t then define SIZEOF_PTHREAD_T
1419 if test "$ac_cv_kpthread" = "yes"
1420 then CC="$CC -Kpthread"
1421 elif test "$ac_cv_kthread" = "yes"
1422 then CC="$CC -Kthread"
1423 elif test "$ac_cv_pthread" = "yes"
1424 then CC="$CC -pthread"
1426 AC_MSG_CHECKING(for pthread_t)
1428 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1429 AC_MSG_RESULT($have_pthread_t)
1430 if test "$have_pthread_t" = yes ; then
1431 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1432 AC_MSG_CHECKING(size of pthread_t)
1433 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1434 [AC_TRY_RUN([#include <stdio.h>
1435 #include <pthread.h>
1438 FILE *f=fopen("conftestval", "w");
1440 fprintf(f, "%d\n", sizeof(pthread_t));
1443 ac_cv_sizeof_pthread_t=`cat conftestval`,
1444 ac_cv_sizeof_pthread_t=0,
1445 ac_cv_sizeof_pthread_t=4)
1447 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1448 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1449 [The number of bytes in a pthread_t.])
1455 AC_SUBST(OTHER_LIBTOOL_OPT)
1456 case $ac_sys_system/$ac_sys_release in
1457 Darwin/@<:@01567@:>@\..*)
1458 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1461 OTHER_LIBTOOL_OPT=""
1465 AC_SUBST(LIBTOOL_CRUFT)
1466 case $ac_sys_system/$ac_sys_release in
1467 Darwin/@<:@01567@:>@\..*)
1468 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1469 if test "${enable_universalsdk}"; then
1472 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1474 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1475 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1477 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1478 if test ${gcc_version} '<' 4.0
1480 LIBTOOL_CRUFT="-lcc_dynamic"
1484 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1485 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1486 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1489 AC_MSG_CHECKING(for --enable-framework)
1490 if test "$enable_framework"
1492 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1493 # -F. is needed to allow linking to the framework while
1494 # in the build location.
1495 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1496 [Define if you want to produce an OpenStep/Rhapsody framework
1497 (shared library plus accessory files).])
1503 AC_MSG_CHECKING(for dyld)
1504 case $ac_sys_system/$ac_sys_release in
1506 AC_DEFINE(WITH_DYLD, 1,
1507 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1508 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1509 linker (rld). Dyld is necessary to support frameworks.])
1510 AC_MSG_RESULT(always on for Darwin)
1517 # Set info about shared libraries.
1522 AC_SUBST(LINKFORSHARED)
1523 # SO is the extension of shared libraries `(including the dot!)
1524 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1528 case $ac_sys_system in
1539 # this might also be a termcap variable, see #610332
1541 echo '====================================================================='
1543 echo '+ WARNING: You have set SO in your environment. +'
1544 echo '+ Do you really mean to change the extension for shared libraries? +'
1545 echo '+ Continuing in 10 seconds to let you to ponder. +'
1547 echo '====================================================================='
1552 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1553 # LDSHARED is the ld *command* used to create shared library
1554 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1555 # (Shared libraries in this instance are shared modules to be loaded into
1556 # Python, as opposed to building Python itself as a shared library.)
1557 AC_MSG_CHECKING(LDSHARED)
1558 if test -z "$LDSHARED"
1560 case $ac_sys_system/$ac_sys_release in
1562 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1563 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1565 IRIX/5*) LDSHARED="ld -shared";;
1566 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1568 if test "$GCC" = "yes"
1569 then LDSHARED='$(CC) -shared'
1570 else LDSHARED='$(CC) -G';
1573 if test "$GCC" = "yes"
1574 then LDSHARED='$(CC) -shared'
1575 else LDSHARED='ld -b';
1577 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1579 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1580 if test "$enable_framework" ; then
1581 # Link against the framework. All externals should be defined.
1582 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1583 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1585 # No framework. Ignore undefined symbols, assuming they come from Python
1586 LDSHARED="$LDSHARED -undefined suppress"
1588 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1589 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1590 if test "$enable_framework" ; then
1591 # Link against the framework. All externals should be defined.
1592 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1593 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1595 # No framework, use the Python app as bundle-loader
1596 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1597 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1600 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1601 # This allows an extension to be used in any Python
1603 if test ${MACOSX_DEPLOYMENT_TARGET} '>' 10.2
1605 if test "${enable_universalsdk}"; then
1606 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1608 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1609 BLDSHARED="$LDSHARED"
1611 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1612 if test "$enable_framework" ; then
1613 # Link against the framework. All externals should be defined.
1614 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1615 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1617 # No framework, use the Python app as bundle-loader
1618 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1619 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1623 Linux*|GNU*|QNX*) LDSHARED='$(CC) -shared';;
1624 BSD/OS*/4*) LDSHARED="gcc -shared";;
1626 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1628 LDSHARED="$CC -shared ${LDFLAGS}"
1630 LDSHARED="ld -Bshareable ${LDFLAGS}"
1633 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1635 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1638 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1639 LDSHARED="ld -Bshareable ${LDFLAGS}"
1642 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1646 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1647 OpenUNIX*|UnixWare*)
1648 if test "$GCC" = "yes"
1649 then LDSHARED='$(CC) -shared'
1650 else LDSHARED='$(CC) -G'
1652 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1653 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1654 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1655 atheos*) LDSHARED="gcc -shared";;
1659 AC_MSG_RESULT($LDSHARED)
1660 BLDSHARED=${BLDSHARED-$LDSHARED}
1661 # CCSHARED are the C *flags* used to create objects to go into a shared
1662 # library (module) -- this is only needed for a few systems
1663 AC_MSG_CHECKING(CCSHARED)
1664 if test -z "$CCSHARED"
1666 case $ac_sys_system/$ac_sys_release in
1667 SunOS*) if test "$GCC" = yes;
1668 then CCSHARED="-fPIC";
1669 elif test `uname -p` = sparc;
1670 then CCSHARED="-xcode=pic32";
1671 else CCSHARED="-Kpic";
1673 hp*|HP*) if test "$GCC" = yes;
1674 then CCSHARED="-fPIC";
1677 Linux*|GNU*) CCSHARED="-fPIC";;
1678 BSD/OS*/4*) CCSHARED="-fpic";;
1679 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1680 OpenUNIX*|UnixWare*)
1681 if test "$GCC" = "yes"
1682 then CCSHARED="-fPIC"
1683 else CCSHARED="-KPIC"
1686 if test "$GCC" = "yes"
1687 then CCSHARED="-fPIC"
1688 else CCSHARED="-Kpic -belf"
1690 Monterey*) CCSHARED="-G";;
1691 IRIX*/6*) case $CC in
1692 *gcc*) CCSHARED="-shared";;
1695 atheos*) CCSHARED="-fPIC";;
1698 AC_MSG_RESULT($CCSHARED)
1699 # LINKFORSHARED are the flags passed to the $(CC) command that links
1700 # the python executable -- this is only needed for a few systems
1701 AC_MSG_CHECKING(LINKFORSHARED)
1702 if test -z "$LINKFORSHARED"
1704 case $ac_sys_system/$ac_sys_release in
1705 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1707 LINKFORSHARED="-Wl,-E -Wl,+s";;
1708 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1709 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1710 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1711 # -u libsys_s pulls in all symbols in libsys
1713 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1715 # not used by the core itself but which needs to be in the core so
1716 # that dynamically loaded extension modules have access to it.
1717 # -prebind is no longer used, because it actually seems to give a
1718 # slowdown in stead of a speedup, maybe due to the large number of
1719 # dynamic loads Python does.
1721 LINKFORSHARED="$extra_undefs"
1722 if test "$enable_framework"
1724 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1726 LINKFORSHARED="$LINKFORSHARED";;
1727 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1728 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1729 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1730 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1731 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1733 LINKFORSHARED="-Wl,--export-dynamic"
1735 SunOS/5*) case $CC in
1737 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1739 LINKFORSHARED="-Xlinker --export-dynamic"
1743 if test $enable_shared = "no"
1745 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1748 # -Wl,-E causes the symbols to be added to the dynamic
1749 # symbol table so that they can be found when a module
1750 # is loaded. -N 2048K causes the stack size to be set
1751 # to 2048 kilobytes so that the stack doesn't overflow
1752 # when running test_compile.py.
1753 LINKFORSHARED='-Wl,-E -N 2048K';;
1756 AC_MSG_RESULT($LINKFORSHARED)
1759 AC_SUBST(CFLAGSFORSHARED)
1760 AC_MSG_CHECKING(CFLAGSFORSHARED)
1761 if test ! "$LIBRARY" = "$LDLIBRARY"
1763 case $ac_sys_system in
1765 # Cygwin needs CCSHARED when building extension DLLs
1766 # but not when building the interpreter DLL.
1767 CFLAGSFORSHARED='';;
1769 CFLAGSFORSHARED='$(CCSHARED)'
1772 AC_MSG_RESULT($CFLAGSFORSHARED)
1774 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1775 # library (with --enable-shared).
1776 # For platforms on which shared libraries are not allowed to have unresolved
1777 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1778 # if it is not required, since it creates a dependency of the shared library
1779 # to LIBS. This, in turn, means that applications linking the shared libpython
1780 # don't need to link LIBS explicitly. The default should be only changed
1781 # on systems where this approach causes problems.
1783 AC_MSG_CHECKING(SHLIBS)
1784 case "$ac_sys_system" in
1788 AC_MSG_RESULT($SHLIBS)
1791 # checks for libraries
1792 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1793 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1795 # only check for sem_init if thread support is requested
1796 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1797 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1798 # posix4 on Solaris 2.6
1799 # pthread (first!) on Linux
1802 # check if we need libintl for locale functions
1803 AC_CHECK_LIB(intl, textdomain,
1804 AC_DEFINE(WITH_LIBINTL, 1,
1805 [Define to 1 if libintl is needed for locale functions.]))
1807 # checks for system dependent C++ extensions support
1808 case "$ac_sys_system" in
1809 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1810 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1811 [loadAndInit("", 0, "")],
1812 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1813 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1814 and you want support for AIX C++ shared extension modules.])
1815 AC_MSG_RESULT(yes)],
1816 [AC_MSG_RESULT(no)]);;
1820 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1821 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1822 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1824 AC_MSG_CHECKING(for --with-libs)
1826 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1828 AC_MSG_RESULT($withval)
1829 LIBS="$withval $LIBS"
1831 [AC_MSG_RESULT(no)])
1833 # Check for use of the system libffi library
1834 AC_MSG_CHECKING(for --with-system-ffi)
1835 AC_ARG_WITH(system_ffi,
1836 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1838 AC_MSG_RESULT($with_system_ffi)
1840 # Determine if signalmodule should be used.
1841 AC_SUBST(USE_SIGNAL_MODULE)
1842 AC_SUBST(SIGNAL_OBJS)
1843 AC_MSG_CHECKING(for --with-signal-module)
1844 AC_ARG_WITH(signal-module,
1845 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1847 if test -z "$with_signal_module"
1848 then with_signal_module="yes"
1850 AC_MSG_RESULT($with_signal_module)
1852 if test "${with_signal_module}" = "yes"; then
1853 USE_SIGNAL_MODULE=""
1856 USE_SIGNAL_MODULE="#"
1857 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1860 # This is used to generate Setup.config
1861 AC_SUBST(USE_THREAD_MODULE)
1862 USE_THREAD_MODULE=""
1864 AC_MSG_CHECKING(for --with-dec-threads)
1866 AC_ARG_WITH(dec-threads,
1867 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1869 AC_MSG_RESULT($withval)
1871 if test "${with_thread+set}" != set; then
1872 with_thread="$withval";
1874 [AC_MSG_RESULT(no)])
1876 # Templates for things AC_DEFINEd more than once.
1877 # For a single AC_DEFINE, no template is needed.
1878 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1879 AH_TEMPLATE(_REENTRANT,
1880 [Define to force use of thread-safe errno, h_errno, and other functions])
1881 AH_TEMPLATE(WITH_THREAD,
1882 [Define if you want to compile in rudimentary thread support])
1884 AC_MSG_CHECKING(for --with-threads)
1885 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1886 AC_ARG_WITH(threads,
1887 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1889 # --with-thread is deprecated, but check for it anyway
1890 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1892 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1893 [with_threads=$with_thread])
1895 if test -z "$with_threads"
1896 then with_threads="yes"
1898 AC_MSG_RESULT($with_threads)
1901 if test "$with_threads" = "no"
1903 USE_THREAD_MODULE="#"
1904 elif test "$ac_cv_pthread_is_default" = yes
1906 AC_DEFINE(WITH_THREAD)
1907 # Defining _REENTRANT on system with POSIX threads should not hurt.
1908 AC_DEFINE(_REENTRANT)
1910 THREADOBJ="Python/thread.o"
1911 elif test "$ac_cv_kpthread" = "yes"
1914 if test "$ac_cv_cxx_thread" = "yes"; then
1915 CXX="$CXX -Kpthread"
1917 AC_DEFINE(WITH_THREAD)
1919 THREADOBJ="Python/thread.o"
1920 elif test "$ac_cv_kthread" = "yes"
1923 if test "$ac_cv_cxx_thread" = "yes"; then
1926 AC_DEFINE(WITH_THREAD)
1928 THREADOBJ="Python/thread.o"
1929 elif test "$ac_cv_pthread" = "yes"
1932 if test "$ac_cv_cxx_thread" = "yes"; then
1935 AC_DEFINE(WITH_THREAD)
1937 THREADOBJ="Python/thread.o"
1939 if test ! -z "$with_threads" -a -d "$with_threads"
1940 then LDFLAGS="$LDFLAGS -L$with_threads"
1942 if test ! -z "$withval" -a -d "$withval"
1943 then LDFLAGS="$LDFLAGS -L$withval"
1946 # According to the POSIX spec, a pthreads implementation must
1947 # define _POSIX_THREADS in unistd.h. Some apparently don't
1948 # (e.g. gnu pth with pthread emulation)
1949 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
1953 #ifdef _POSIX_THREADS
1956 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
1957 AC_MSG_RESULT($unistd_defines_pthreads)
1959 AC_DEFINE(_REENTRANT)
1960 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
1961 AC_DEFINE(C_THREADS)
1962 AC_DEFINE(HURD_C_THREADS, 1,
1963 [Define if you are using Mach cthreads directly under /include])
1964 LIBS="$LIBS -lthreads"
1965 THREADOBJ="Python/thread.o"],[
1966 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
1967 AC_DEFINE(C_THREADS)
1968 AC_DEFINE(MACH_C_THREADS, 1,
1969 [Define if you are using Mach cthreads under mach /])
1970 THREADOBJ="Python/thread.o"],[
1971 AC_MSG_CHECKING(for --with-pth)
1973 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
1974 [AC_MSG_RESULT($withval)
1975 AC_DEFINE([WITH_THREAD])
1976 AC_DEFINE([HAVE_PTH], 1,
1977 [Define if you have GNU PTH threads.])
1979 THREADOBJ="Python/thread.o"],
1982 # Just looking for pthread_create in libpthread is not enough:
1983 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
1984 # So we really have to include pthread.h, and then link.
1986 LIBS="$LIBS -lpthread"
1987 AC_MSG_CHECKING([for pthread_create in -lpthread])
1988 AC_TRY_LINK([#include <pthread.h>
1990 void * start_routine (void *arg) { exit (0); }], [
1991 pthread_create (NULL, NULL, start_routine, NULL)], [
1993 AC_DEFINE(WITH_THREAD)
1995 THREADOBJ="Python/thread.o"],[
1997 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
1999 THREADOBJ="Python/thread.o"],[
2000 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
2001 AC_DEFINE(ATHEOS_THREADS, 1,
2002 [Define this if you have AtheOS threads.])
2003 THREADOBJ="Python/thread.o"],[
2004 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
2006 LIBS="$LIBS -lpthreads"
2007 THREADOBJ="Python/thread.o"], [
2008 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
2011 THREADOBJ="Python/thread.o"], [
2012 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
2014 LIBS="$LIBS -lpthread"
2015 THREADOBJ="Python/thread.o"], [
2016 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
2019 THREADOBJ="Python/thread.o"],[
2020 USE_THREAD_MODULE="#"])
2023 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
2025 THREADOBJ="Python/thread.o"
2026 USE_THREAD_MODULE=""])
2028 if test "$posix_threads" != "yes"; then
2029 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
2030 LIBS="$LIBS -lthread"
2031 THREADOBJ="Python/thread.o"
2032 USE_THREAD_MODULE=""])
2035 if test "$USE_THREAD_MODULE" != "#"
2037 # If the above checks didn't disable threads, (at least) OSF1
2038 # needs this '-threads' argument during linking.
2039 case $ac_sys_system in
2040 OSF1) LDLAST=-threads;;
2045 if test "$posix_threads" = "yes"; then
2046 if test "$unistd_defines_pthreads" = "no"; then
2047 AC_DEFINE(_POSIX_THREADS, 1,
2048 [Define if you have POSIX threads,
2049 and your system does not define that.])
2052 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
2053 case $ac_sys_system/$ac_sys_release in
2054 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
2055 Defined for Solaris 2.6 bug in pthread header.)
2057 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2058 Define if the Posix semaphores do not work on your system)
2060 AIX/5) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2061 Define if the Posix semaphores do not work on your system)
2065 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
2066 AC_CACHE_VAL(ac_cv_pthread_system_supported,
2067 [AC_TRY_RUN([#include <pthread.h>
2068 void *foo(void *parm) {
2072 pthread_attr_t attr;
2074 if (pthread_attr_init(&attr)) exit(-1);
2075 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
2076 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
2079 ac_cv_pthread_system_supported=yes,
2080 ac_cv_pthread_system_supported=no,
2081 ac_cv_pthread_system_supported=no)
2083 AC_MSG_RESULT($ac_cv_pthread_system_supported)
2084 if test "$ac_cv_pthread_system_supported" = "yes"; then
2085 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2087 AC_CHECK_FUNCS(pthread_sigmask,
2088 [case $ac_sys_system in
2090 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2091 [Define if pthread_sigmask() does not work on your system.])
2097 # Check for enable-ipv6
2098 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2099 AC_MSG_CHECKING([if --enable-ipv6 is specified])
2101 [ --enable-ipv6 Enable ipv6 (with ipv4) support
2102 --disable-ipv6 Disable ipv6 support],
2103 [ case "$enableval" in
2108 *) AC_MSG_RESULT(yes)
2109 AC_DEFINE(ENABLE_IPV6)
2115 dnl the check does not work on cross compilation case...
2116 AC_TRY_RUN([ /* AF_INET6 available check */
2117 #include <sys/types.h>
2118 #include <sys/socket.h>
2121 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2135 if test "$ipv6" = "yes"; then
2136 AC_MSG_CHECKING(if RFC2553 API is available)
2137 AC_TRY_COMPILE([#include <sys/types.h>
2138 #include <netinet/in.h>],
2139 [struct sockaddr_in6 x;
2143 AC_MSG_RESULT(no, IPv6 disabled)
2147 if test "$ipv6" = "yes"; then
2148 AC_DEFINE(ENABLE_IPV6)
2156 if test "$ipv6" = "yes"; then
2157 AC_MSG_CHECKING([ipv6 stack type])
2158 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2162 dnl http://www.kame.net/
2164 #include <netinet/in.h>
2165 #ifdef IPV6_INRIA_VERSION
2171 dnl http://www.kame.net/
2173 #include <netinet/in.h>
2179 ipv6libdir=/usr/local/v6/lib
2183 dnl http://www.v6.linux.or.jp/
2185 #include <features.h>
2186 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2193 dnl http://www.v6.linux.or.jp/
2194 if test -d /usr/inet6; then
2197 ipv6libdir=/usr/inet6/lib
2198 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2202 if test -f /etc/netconfig; then
2203 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2211 #include <sys/param.h>
2212 #ifdef _TOSHIBA_INET6
2217 ipv6libdir=/usr/local/v6/lib])
2221 #include </usr/local/v6/include/sys/v6config.h>
2227 ipv6libdir=/usr/local/v6/lib;
2228 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2232 #include <sys/param.h>
2233 #ifdef _ZETA_MINAMI_INET6
2238 ipv6libdir=/usr/local/v6/lib])
2241 if test "$ipv6type" != "unknown"; then
2245 AC_MSG_RESULT($ipv6type)
2248 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2249 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2250 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2251 echo "using lib$ipv6lib"
2253 if test $ipv6trylibc = "yes"; then
2256 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2257 echo "You need to fetch lib$ipv6lib.a from appropriate"
2258 echo 'ipv6 kit and compile beforehand.'
2264 AC_MSG_CHECKING(for OSX 10.5 SDK or later)
2265 AC_TRY_COMPILE([#include <Carbon/Carbon.h>], FSIORefNum fRef = 0,
2266 AC_DEFINE(HAVE_OSX105_SDK, 1, Define if compiling using MacOS X 10.5 SDK or later.)
2271 # Check for --with-doc-strings
2272 AC_MSG_CHECKING(for --with-doc-strings)
2273 AC_ARG_WITH(doc-strings,
2274 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2276 if test -z "$with_doc_strings"
2277 then with_doc_strings="yes"
2279 if test "$with_doc_strings" != "no"
2281 AC_DEFINE(WITH_DOC_STRINGS, 1,
2282 [Define if you want documentation strings in extension modules])
2284 AC_MSG_RESULT($with_doc_strings)
2286 # Check for Python-specific malloc support
2287 AC_MSG_CHECKING(for --with-tsc)
2289 [ --with(out)-tsc enable/disable timestamp counter profile], [
2290 if test "$withval" != no
2292 AC_DEFINE(WITH_TSC, 1,
2293 [Define to profile with the Pentium timestamp counter])
2295 else AC_MSG_RESULT(no)
2297 [AC_MSG_RESULT(no)])
2299 # Check for Python-specific malloc support
2300 AC_MSG_CHECKING(for --with-pymalloc)
2301 AC_ARG_WITH(pymalloc,
2302 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2304 if test -z "$with_pymalloc"
2305 then with_pymalloc="yes"
2307 if test "$with_pymalloc" != "no"
2309 AC_DEFINE(WITH_PYMALLOC, 1,
2310 [Define if you want to compile in Python-specific mallocs])
2312 AC_MSG_RESULT($with_pymalloc)
2314 # Check for --with-wctype-functions
2315 AC_MSG_CHECKING(for --with-wctype-functions)
2316 AC_ARG_WITH(wctype-functions,
2317 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2319 if test "$withval" != no
2321 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2322 [Define if you want wctype.h functions to be used instead of the
2323 one supplied by Python itself. (see Include/unicodectype.h).])
2325 else AC_MSG_RESULT(no)
2327 [AC_MSG_RESULT(no)])
2329 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2333 # the dlopen() function means we might want to use dynload_shlib.o. some
2334 # platforms, such as AIX, have dlopen(), but don't want to use it.
2335 AC_CHECK_FUNCS(dlopen)
2337 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2338 # loading of modules.
2339 AC_SUBST(DYNLOADFILE)
2340 AC_MSG_CHECKING(DYNLOADFILE)
2341 if test -z "$DYNLOADFILE"
2343 case $ac_sys_system/$ac_sys_release in
2344 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2345 if test "$ac_cv_func_dlopen" = yes
2346 then DYNLOADFILE="dynload_shlib.o"
2347 else DYNLOADFILE="dynload_aix.o"
2350 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2351 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2352 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2353 atheos*) DYNLOADFILE="dynload_atheos.o";;
2355 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2356 # out any dynamic loading
2357 if test "$ac_cv_func_dlopen" = yes
2358 then DYNLOADFILE="dynload_shlib.o"
2359 else DYNLOADFILE="dynload_stub.o"
2364 AC_MSG_RESULT($DYNLOADFILE)
2365 if test "$DYNLOADFILE" != "dynload_stub.o"
2367 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2368 [Defined when any dynamic module loading is enabled.])
2371 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2373 AC_SUBST(MACHDEP_OBJS)
2374 AC_MSG_CHECKING(MACHDEP_OBJS)
2375 if test -z "$MACHDEP_OBJS"
2377 MACHDEP_OBJS=$extra_machdep_objs
2379 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2381 AC_MSG_RESULT(MACHDEP_OBJS)
2383 # checks for library functions
2384 AC_CHECK_FUNCS(alarm setitimer getitimer bind_textdomain_codeset chown \
2385 clock confstr ctermid execv fchmod fchown fork fpathconf ftime ftruncate \
2386 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2387 getpriority getpwent getspnam getspent getsid getwd \
2388 kill killpg lchmod lchown lstat mkfifo mknod mktime \
2389 mremap nice pathconf pause plock poll pthread_init \
2390 putenv readlink realpath \
2391 select sem_open sem_timedwait sem_getvalue sem_unlink setegid seteuid \
2393 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2394 sigaction siginterrupt sigrelse strftime strlcpy \
2395 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2396 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll wcsxfrm _getpty)
2398 # For some functions, having a definition is not sufficient, since
2399 # we want to take their address.
2400 AC_MSG_CHECKING(for chroot)
2401 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2402 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2406 AC_MSG_CHECKING(for link)
2407 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2408 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2412 AC_MSG_CHECKING(for symlink)
2413 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2414 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2418 AC_MSG_CHECKING(for fchdir)
2419 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2420 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2424 AC_MSG_CHECKING(for fsync)
2425 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2426 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2430 AC_MSG_CHECKING(for fdatasync)
2431 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2432 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2436 AC_MSG_CHECKING(for epoll)
2437 AC_TRY_COMPILE([#include <sys/epoll.h>], void *x=epoll_create,
2438 AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
2442 AC_MSG_CHECKING(for kqueue)
2444 #include <sys/types.h>
2445 #include <sys/event.h>
2447 AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
2451 # On some systems (eg. FreeBSD 5), we would find a definition of the
2452 # functions ctermid_r, setgroups in the library, but no prototype
2453 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2454 # address to avoid compiler warnings and potential miscompilations
2455 # because of the missing prototypes.
2457 AC_MSG_CHECKING(for ctermid_r)
2459 #include "confdefs.h"
2461 ], void* p = ctermid_r,
2462 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2467 AC_MSG_CHECKING(for flock)
2469 #include "confdefs.h"
2470 #include <sys/file.h>
2472 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2477 AC_MSG_CHECKING(for getpagesize)
2479 #include "confdefs.h"
2481 ], void* p = getpagesize,
2482 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2488 AC_CHECK_PROGS(TRUE, true, /bin/true)
2490 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2491 dnl On others, they are in the C library, so we to take no action
2492 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2493 AC_CHECK_LIB(resolv, inet_aton)
2496 # On Tru64, chflags seems to be present, but calling it will
2498 AC_MSG_CHECKING(for chflags)
2500 #include <sys/stat.h>
2502 int main(int argc, char*argv[])
2504 if(chflags(argv[0], 0) != 0)
2508 ],AC_DEFINE(HAVE_CHFLAGS, 1, Define to 1 if you have the `chflags' function.)
2513 AC_MSG_CHECKING(for lchflags)
2515 #include <sys/stat.h>
2517 int main(int argc, char*argv[])
2519 if(lchflags(argv[0], 0) != 0)
2523 ],AC_DEFINE(HAVE_LCHFLAGS, 1, Define to 1 if you have the `lchflags' function.)
2528 dnl Check if system zlib has *Copy() functions
2530 dnl On MacOSX the linker will search for dylibs on the entire linker path
2531 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2532 dnl to revert to a more traditional unix behaviour and make it possible to
2533 dnl override the system libz with a local static library of libz. Temporarily
2534 dnl add that flag to our CFLAGS as well to ensure that we check the version
2535 dnl of libz that will be used by setup.py.
2536 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2537 dnl environment as setup.py (and leaving it out can cause configure to use the
2538 dnl wrong version of the library)
2539 case $ac_sys_system/$ac_sys_release in
2541 _CUR_CFLAGS="${CFLAGS}"
2542 _CUR_LDFLAGS="${LDFLAGS}"
2543 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2544 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2548 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2550 case $ac_sys_system/$ac_sys_release in
2552 CFLAGS="${_CUR_CFLAGS}"
2553 LDFLAGS="${_CUR_LDFLAGS}"
2557 AC_MSG_CHECKING(for hstrerror)
2559 #include "confdefs.h"
2561 ], void* p = hstrerror; hstrerror(0),
2562 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2567 AC_MSG_CHECKING(for inet_aton)
2569 #include "confdefs.h"
2570 #include <sys/types.h>
2571 #include <sys/socket.h>
2572 #include <netinet/in.h>
2573 #include <arpa/inet.h>
2574 ], void* p = inet_aton;inet_aton(0,0),
2575 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2580 AC_MSG_CHECKING(for inet_pton)
2582 #include "confdefs.h"
2583 #include <sys/types.h>
2584 #include <sys/socket.h>
2585 #include <netinet/in.h>
2586 #include <arpa/inet.h>
2587 ], void* p = inet_pton,
2588 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2593 # On some systems, setgroups is in unistd.h, on others, in grp.h
2594 AC_MSG_CHECKING(for setgroups)
2596 #include "confdefs.h"
2602 void* p = setgroups,
2603 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2608 # check for openpty and forkpty
2610 AC_CHECK_FUNCS(openpty,,
2611 AC_CHECK_LIB(util,openpty,
2612 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2613 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2616 AC_CHECK_FUNCS(forkpty,,
2617 AC_CHECK_LIB(util,forkpty,
2618 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2619 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2624 AC_CHECK_FUNCS(memmove)
2626 # check for long file support functions
2627 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2629 AC_REPLACE_FUNCS(dup2 getcwd strdup)
2630 AC_CHECK_FUNCS(getpgrp,
2631 AC_TRY_COMPILE([#include <unistd.h>],
2633 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2634 [Define if getpgrp() must be called as getpgrp(0).])
2637 AC_CHECK_FUNCS(setpgrp,
2638 AC_TRY_COMPILE([#include <unistd.h>],
2640 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2641 [Define if setpgrp() must be called as setpgrp(0, 0).])
2644 AC_CHECK_FUNCS(gettimeofday,
2645 AC_TRY_COMPILE([#include <sys/time.h>],
2646 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2647 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2648 [Define if gettimeofday() does not have second (timezone) argument
2649 This is the case on Motorola V4 (R40V4.2)])
2653 AC_MSG_CHECKING(for major, minor, and makedev)
2655 #if defined(MAJOR_IN_MKDEV)
2656 #include <sys/mkdev.h>
2657 #elif defined(MAJOR_IN_SYSMACROS)
2658 #include <sys/sysmacros.h>
2660 #include <sys/types.h>
2663 makedev(major(0),minor(0));
2665 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2666 [Define to 1 if you have the device macros.])
2672 # On OSF/1 V5.1, getaddrinfo is available, but a define
2673 # for [no]getaddrinfo in netdb.h.
2674 AC_MSG_CHECKING(for getaddrinfo)
2676 #include <sys/types.h>
2677 #include <sys/socket.h>
2681 getaddrinfo(NULL, NULL, NULL, NULL);
2684 AC_MSG_CHECKING(getaddrinfo bug)
2686 #include <sys/types.h>
2689 #include <sys/socket.h>
2690 #include <netinet/in.h>
2694 int passive, gaierr, inet4 = 0, inet6 = 0;
2695 struct addrinfo hints, *ai, *aitop;
2696 char straddr[INET6_ADDRSTRLEN], strport[16];
2698 for (passive = 0; passive <= 1; passive++) {
2699 memset(&hints, 0, sizeof(hints));
2700 hints.ai_family = AF_UNSPEC;
2701 hints.ai_flags = passive ? AI_PASSIVE : 0;
2702 hints.ai_socktype = SOCK_STREAM;
2703 hints.ai_protocol = IPPROTO_TCP;
2704 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2705 (void)gai_strerror(gaierr);
2708 for (ai = aitop; ai; ai = ai->ai_next) {
2709 if (ai->ai_addr == NULL ||
2710 ai->ai_addrlen == 0 ||
2711 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2712 straddr, sizeof(straddr), strport, sizeof(strport),
2713 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2716 switch (ai->ai_family) {
2718 if (strcmp(strport, "54321") != 0) {
2722 if (strcmp(straddr, "0.0.0.0") != 0) {
2726 if (strcmp(straddr, "127.0.0.1") != 0) {
2733 if (strcmp(strport, "54321") != 0) {
2737 if (strcmp(straddr, "::") != 0) {
2741 if (strcmp(straddr, "::1") != 0) {
2751 /* another family support? */
2757 if (!(inet4 == 0 || inet4 == 2))
2759 if (!(inet6 == 0 || inet6 == 2))
2763 freeaddrinfo(aitop);
2768 freeaddrinfo(aitop);
2773 buggygetaddrinfo=no,
2774 AC_MSG_RESULT(buggy)
2775 buggygetaddrinfo=yes,
2776 AC_MSG_RESULT(buggy)
2777 buggygetaddrinfo=yes)], [
2779 buggygetaddrinfo=yes
2782 if test "$buggygetaddrinfo" = "yes"; then
2783 if test "$ipv6" = "yes"; then
2784 echo 'Fatal: You must get working getaddrinfo() function.'
2785 echo ' or you can specify "--disable-ipv6"'.
2789 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2791 AC_CHECK_FUNCS(getnameinfo)
2793 # checks for structures
2797 AC_CHECK_MEMBERS([struct stat.st_rdev])
2798 AC_CHECK_MEMBERS([struct stat.st_blksize])
2799 AC_CHECK_MEMBERS([struct stat.st_flags])
2800 AC_CHECK_MEMBERS([struct stat.st_gen])
2801 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2804 AC_MSG_CHECKING(for time.h that defines altzone)
2805 AC_CACHE_VAL(ac_cv_header_time_altzone,
2806 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2807 ac_cv_header_time_altzone=yes,
2808 ac_cv_header_time_altzone=no)])
2809 AC_MSG_RESULT($ac_cv_header_time_altzone)
2810 if test $ac_cv_header_time_altzone = yes; then
2811 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2815 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2817 #include <sys/types.h>
2818 #include <sys/select.h>
2819 #include <sys/time.h>
2821 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2822 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2823 (which you can't on SCO ODT 3.0).])
2826 AC_MSG_RESULT($was_it_defined)
2828 AC_MSG_CHECKING(for addrinfo)
2829 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2831 # include <netdb.h>],
2832 [struct addrinfo a],
2833 ac_cv_struct_addrinfo=yes,
2834 ac_cv_struct_addrinfo=no))
2835 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2836 if test $ac_cv_struct_addrinfo = yes; then
2837 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2840 AC_MSG_CHECKING(for sockaddr_storage)
2841 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2843 # include <sys/types.h>
2844 # include <sys/socket.h>],
2845 [struct sockaddr_storage s],
2846 ac_cv_struct_sockaddr_storage=yes,
2847 ac_cv_struct_sockaddr_storage=no))
2848 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2849 if test $ac_cv_struct_sockaddr_storage = yes; then
2850 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2853 # checks for compiler characteristics
2859 AC_MSG_CHECKING(for working volatile)
2860 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2861 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2863 AC_MSG_RESULT($works)
2866 AC_MSG_CHECKING(for working signed char)
2867 AC_TRY_COMPILE([], [signed char c;], works=yes,
2868 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2870 AC_MSG_RESULT($works)
2873 AC_MSG_CHECKING(for prototypes)
2874 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2875 AC_DEFINE(HAVE_PROTOTYPES, 1,
2876 [Define if your compiler supports function prototype])
2879 AC_MSG_RESULT($have_prototypes)
2882 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2885 int foo(int x, ...) {
2893 ], [return foo(10, "", 3.14);], [
2894 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2895 [Define if your compiler supports variable length function prototypes
2896 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2899 AC_MSG_RESULT($works)
2901 # check for socketpair
2902 AC_MSG_CHECKING(for socketpair)
2904 #include <sys/types.h>
2905 #include <sys/socket.h>
2906 ], void *x=socketpair,
2907 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2912 # check if sockaddr has sa_len member
2913 AC_MSG_CHECKING(if sockaddr has sa_len member)
2914 AC_TRY_COMPILE([#include <sys/types.h>
2915 #include <sys/socket.h>],
2919 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2923 AC_MSG_CHECKING(whether va_list is an array)
2925 #ifdef HAVE_STDARG_PROTOTYPES
2928 #include <varargs.h>
2930 ], [va_list list1, list2; list1 = list2;], , [
2931 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2932 va_list_is_array=yes
2934 AC_MSG_RESULT($va_list_is_array)
2936 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2937 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2938 [Define this if you have some version of gethostbyname_r()])
2940 AC_CHECK_FUNC(gethostbyname_r, [
2941 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2942 AC_MSG_CHECKING([gethostbyname_r with 6 args])
2944 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2949 struct hostent *he, *res;
2954 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2956 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2957 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
2958 [Define this if you have the 6-arg version of gethostbyname_r().])
2962 AC_MSG_CHECKING([gethostbyname_r with 5 args])
2972 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2974 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2975 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
2976 [Define this if you have the 5-arg version of gethostbyname_r().])
2980 AC_MSG_CHECKING([gethostbyname_r with 3 args])
2986 struct hostent_data data;
2988 (void) gethostbyname_r(name, he, &data);
2990 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2991 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
2992 [Define this if you have the 3-arg version of gethostbyname_r().])
3001 AC_CHECK_FUNCS(gethostbyname)
3003 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
3004 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
3005 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
3006 AC_SUBST(HAVE_GETHOSTBYNAME_R)
3007 AC_SUBST(HAVE_GETHOSTBYNAME)
3009 # checks for system services
3012 # Linux requires this for correct f.p. operations
3013 AC_CHECK_FUNC(__fpu_control,
3015 [AC_CHECK_LIB(ieee, __fpu_control)
3018 # Check for --with-fpectl
3019 AC_MSG_CHECKING(for --with-fpectl)
3021 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
3023 if test "$withval" != no
3025 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
3026 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
3028 else AC_MSG_RESULT(no)
3030 [AC_MSG_RESULT(no)])
3032 # check for --with-libm=...
3034 case $ac_sys_system in
3038 AC_MSG_CHECKING(for --with-libm=STRING)
3040 AC_HELP_STRING(--with-libm=STRING, math library),
3042 if test "$withval" = no
3044 AC_MSG_RESULT(force LIBM empty)
3045 elif test "$withval" != yes
3047 AC_MSG_RESULT(set LIBM="$withval")
3048 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
3050 [AC_MSG_RESULT(default LIBM="$LIBM")])
3052 # check for --with-libc=...
3054 AC_MSG_CHECKING(for --with-libc=STRING)
3056 AC_HELP_STRING(--with-libc=STRING, C library),
3058 if test "$withval" = no
3060 AC_MSG_RESULT(force LIBC empty)
3061 elif test "$withval" != yes
3063 AC_MSG_RESULT(set LIBC="$withval")
3064 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
3066 [AC_MSG_RESULT(default LIBC="$LIBC")])
3068 # ************************************
3069 # * Check for mathematical functions *
3070 # ************************************
3075 # Detect whether system arithmetic is subject to x87-style double
3076 # rounding issues. The result of this test has little meaning on non
3077 # IEEE 754 platforms. On IEEE 754, test should return 1 if rounding
3078 # mode is round-to-nearest and double rounding issues are present, and
3079 # 0 otherwise. See http://bugs.python.org/issue2937 for more info.
3080 AC_MSG_CHECKING(for x87-style double rounding)
3081 AC_CACHE_VAL(ac_cv_x87_double_rounding, [
3086 volatile double x, y, z;
3087 /* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */
3088 x = 0.99999999999999989; /* 1-2**-53 */
3092 /* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
3098 /* both tests show evidence of double rounding */
3102 ac_cv_x87_double_rounding=no,
3103 ac_cv_x87_double_rounding=yes,
3104 ac_cv_x87_double_rounding=no)])
3105 AC_MSG_RESULT($ac_cv_x87_double_rounding)
3106 if test "$ac_cv_x87_double_rounding" = yes
3108 AC_DEFINE(X87_DOUBLE_ROUNDING, 1,
3109 [Define if arithmetic is subject to x87-style double rounding issue])
3112 # Multiprocessing check for broken sem_getvalue
3113 AC_MSG_CHECKING(for broken sem_getvalue)
3118 #include <semaphore.h>
3119 #include <sys/stat.h>
3122 sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR|S_IWUSR, 0);
3130 res = sem_getvalue(a, &count);
3132 return res==-1 ? 1 : 0;
3137 AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1, define to 1 if your sem_getvalue is broken.)
3140 # On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
3141 # -0. on some architectures.
3142 AC_MSG_CHECKING(whether tanh preserves the sign of zero)
3143 AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
3148 /* return 0 if either negative zeros don't exist
3149 on this platform or if negative zeros exist
3150 and tanh(-0.) == -0. */
3151 if (atan2(0., -1.) == atan2(-0., -1.) ||
3152 atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
3156 ac_cv_tanh_preserves_zero_sign=yes,
3157 ac_cv_tanh_preserves_zero_sign=no,
3158 ac_cv_tanh_preserves_zero_sign=no)])
3159 AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
3160 if test "$ac_cv_tanh_preserves_zero_sign" = yes
3162 AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
3163 [Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
3166 AC_CHECK_FUNCS([acosh asinh atanh copysign expm1 finite hypot log1p])
3167 AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]])
3171 # determine what size digit to use for Python's longs
3172 AC_MSG_CHECKING([digit size for Python's longs])
3173 AC_ARG_ENABLE(big-digits,
3174 AC_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
3175 [case $enable_big_digits in
3177 enable_big_digits=30 ;;
3179 enable_big_digits=15 ;;
3183 AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
3185 AC_MSG_RESULT($enable_big_digits)
3186 AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits])
3188 [AC_MSG_RESULT(no value specified)])
3191 AC_CHECK_HEADER(wchar.h, [
3192 AC_DEFINE(HAVE_WCHAR_H, 1,
3193 [Define if the compiler provides a wchar.h header file.])
3199 # determine wchar_t size
3200 if test "$wchar_h" = yes
3202 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
3205 AC_MSG_CHECKING(for UCS-4 tcl)
3209 #if TCL_UTF_MAX != 6
3210 # error "NOT UCS4_TCL"
3212 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
3215 AC_MSG_RESULT($have_ucs4_tcl)
3217 # check whether wchar_t is signed or not
3218 if test "$wchar_h" = yes
3220 # check whether wchar_t is signed or not
3221 AC_MSG_CHECKING(whether wchar_t is signed)
3222 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
3227 /* Success: exit code 0 */
3228 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
3231 ac_cv_wchar_t_signed=yes,
3232 ac_cv_wchar_t_signed=no,
3233 ac_cv_wchar_t_signed=yes)])
3234 AC_MSG_RESULT($ac_cv_wchar_t_signed)
3237 AC_MSG_CHECKING(what type to use for str)
3238 AC_ARG_WITH(wide-unicode,
3239 AC_HELP_STRING(--with-wide-unicode, Use 4-byte Unicode characters (default is 2 bytes)),
3241 if test "$withval" != no
3242 then unicode_size="4"
3243 else unicode_size="2"
3247 case "$have_ucs4_tcl" in
3248 yes) unicode_size="4" ;;
3249 *) unicode_size="2" ;;
3253 AH_TEMPLATE(Py_UNICODE_SIZE,
3254 [Define as the size of the unicode type.])
3255 case "$unicode_size" in
3256 4) AC_DEFINE(Py_UNICODE_SIZE, 4) ;;
3257 *) AC_DEFINE(Py_UNICODE_SIZE, 2) ;;
3260 AH_TEMPLATE(PY_UNICODE_TYPE,
3261 [Define as the integral type used for Unicode representation.])
3263 # wchar_t is only usable if it maps to an unsigned type
3264 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3265 -a "$ac_cv_wchar_t_signed" = "no"
3267 PY_UNICODE_TYPE="wchar_t"
3268 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3269 [Define if you have a useable wchar_t type defined in wchar.h; useable
3270 means wchar_t must be an unsigned type with at least 16 bits. (see
3271 Include/unicodeobject.h).])
3272 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3273 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3275 PY_UNICODE_TYPE="unsigned short"
3276 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3277 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3279 PY_UNICODE_TYPE="unsigned long"
3280 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3282 PY_UNICODE_TYPE="no type found"
3284 AC_MSG_RESULT($PY_UNICODE_TYPE)
3286 # check for endianness
3289 # Check whether right shifting a negative integer extends the sign bit
3290 # or fills with zeros (like the Cray J90, according to Tim Peters).
3291 AC_MSG_CHECKING(whether right shift extends the sign bit)
3292 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3296 exit(((-1)>>3 == -1) ? 0 : 1);
3299 ac_cv_rshift_extends_sign=yes,
3300 ac_cv_rshift_extends_sign=no,
3301 ac_cv_rshift_extends_sign=yes)])
3302 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3303 if test "$ac_cv_rshift_extends_sign" = no
3305 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3306 [Define if i>>j for signed int i does not extend the sign bit
3310 # check for getc_unlocked and related locking functions
3311 AC_MSG_CHECKING(for getc_unlocked() and friends)
3312 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3313 AC_TRY_LINK([#include <stdio.h>],[
3314 FILE *f = fopen("/dev/null", "r");
3318 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3319 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3320 if test "$ac_cv_have_getc_unlocked" = yes
3322 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3323 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3326 # check where readline lives
3327 # save the value of LIBS so we don't actually link Python with readline
3328 LIBS_no_readline=$LIBS
3330 # On some systems we need to link readline to a termcap compatible
3331 # library. NOTE: Keep the precedence of listed libraries synchronised
3333 py_cv_lib_readline=no
3334 AC_MSG_CHECKING([how to link readline libs])
3335 for py_libtermcap in "" ncursesw ncurses curses termcap; do
3336 if test -z "$py_libtermcap"; then
3337 READLINE_LIBS="-lreadline"
3339 READLINE_LIBS="-lreadline -l$py_libtermcap"
3341 LIBS="$READLINE_LIBS $LIBS_no_readline"
3343 [AC_LANG_CALL([],[readline])],
3344 [py_cv_lib_readline=yes])
3345 if test $py_cv_lib_readline = yes; then
3349 # Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
3350 #AC_SUBST([READLINE_LIBS])
3351 if test $py_cv_lib_readline = no; then
3352 AC_MSG_RESULT([none])
3354 AC_MSG_RESULT([$READLINE_LIBS])
3355 AC_DEFINE(HAVE_LIBREADLINE, 1,
3356 [Define if you have the readline library (-lreadline).])
3359 # check for readline 2.1
3360 AC_CHECK_LIB(readline, rl_callback_handler_install,
3361 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3362 [Define if you have readline 2.1]), ,$READLINE_LIBS)
3364 # check for readline 2.2
3365 AC_TRY_CPP([#include <readline/readline.h>],
3366 have_readline=yes, have_readline=no)
3367 if test $have_readline = yes
3369 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3370 [readline/readline.h],
3371 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3372 [Define if you have readline 2.2]), )
3375 # check for readline 4.0
3376 AC_CHECK_LIB(readline, rl_pre_input_hook,
3377 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3378 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3381 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
3382 AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
3383 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3385 # check for readline 4.2
3386 AC_CHECK_LIB(readline, rl_completion_matches,
3387 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3388 [Define if you have readline 4.2]), ,$READLINE_LIBS)
3390 # also in readline 4.2
3391 AC_TRY_CPP([#include <readline/readline.h>],
3392 have_readline=yes, have_readline=no)
3393 if test $have_readline = yes
3395 AC_EGREP_HEADER([extern int rl_catch_signals;],
3396 [readline/readline.h],
3397 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3398 [Define if you can turn off readline's signal handling.]), )
3401 # End of readline checks: restore LIBS
3402 LIBS=$LIBS_no_readline
3404 AC_MSG_CHECKING(for broken nice())
3405 AC_CACHE_VAL(ac_cv_broken_nice, [
3410 if (val1 != -1 && val1 == nice(2))
3415 ac_cv_broken_nice=yes,
3416 ac_cv_broken_nice=no,
3417 ac_cv_broken_nice=no)])
3418 AC_MSG_RESULT($ac_cv_broken_nice)
3419 if test "$ac_cv_broken_nice" = yes
3421 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3422 [Define if nice() returns success/failure instead of the new priority.])
3425 AC_MSG_CHECKING(for broken poll())
3431 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3435 int poll_test = poll (&poll_struct, 1, 0);
3441 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3451 ac_cv_broken_poll=yes,
3452 ac_cv_broken_poll=no,
3453 ac_cv_broken_poll=no)
3454 AC_MSG_RESULT($ac_cv_broken_poll)
3455 if test "$ac_cv_broken_poll" = yes
3457 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3458 [Define if poll() sets errno on invalid file descriptors.])
3461 # Before we can test tzset, we need to check if struct tm has a tm_zone
3462 # (which is not required by ISO C or UNIX spec) and/or if we support
3466 # check tzset(3) exists and works like we expect it to
3467 AC_MSG_CHECKING(for working tzset())
3468 AC_CACHE_VAL(ac_cv_working_tzset, [
3475 extern char *tzname[];
3480 /* Note that we need to ensure that not only does tzset(3)
3481 do 'something' with localtime, but it works as documented
3482 in the library reference and as expected by the test suite.
3483 This includes making sure that tzname is set properly if
3484 tm->tm_zone does not exist since it is the alternative way
3485 of getting timezone info.
3487 Red Hat 6.2 doesn't understand the southern hemisphere
3488 after New Year's Day.
3491 time_t groundhogday = 1044144000; /* GMT-based */
3492 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3496 if (localtime(&groundhogday)->tm_hour != 0)
3499 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3500 if (strcmp(tzname[0], "UTC") ||
3501 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3505 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3507 if (localtime(&groundhogday)->tm_hour != 19)
3510 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3514 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3516 if (localtime(&groundhogday)->tm_hour != 11)
3519 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3523 #if HAVE_STRUCT_TM_TM_ZONE
3524 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3526 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3533 ac_cv_working_tzset=yes,
3534 ac_cv_working_tzset=no,
3535 ac_cv_working_tzset=no)])
3536 AC_MSG_RESULT($ac_cv_working_tzset)
3537 if test "$ac_cv_working_tzset" = yes
3539 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3540 [Define if tzset() actually switches the local timezone in a meaningful way.])
3543 # Look for subsecond timestamps in struct stat
3544 AC_MSG_CHECKING(for tv_nsec in struct stat)
3545 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3546 AC_TRY_COMPILE([#include <sys/stat.h>], [
3548 st.st_mtim.tv_nsec = 1;
3550 ac_cv_stat_tv_nsec=yes,
3551 ac_cv_stat_tv_nsec=no,
3552 ac_cv_stat_tv_nsec=no))
3553 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3554 if test "$ac_cv_stat_tv_nsec" = yes
3556 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3557 [Define if you have struct stat.st_mtim.tv_nsec])
3560 # Look for BSD style subsecond timestamps in struct stat
3561 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3562 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3563 AC_TRY_COMPILE([#include <sys/stat.h>], [
3565 st.st_mtimespec.tv_nsec = 1;
3567 ac_cv_stat_tv_nsec2=yes,
3568 ac_cv_stat_tv_nsec2=no,
3569 ac_cv_stat_tv_nsec2=no))
3570 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3571 if test "$ac_cv_stat_tv_nsec2" = yes
3573 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3574 [Define if you have struct stat.st_mtimensec])
3577 # On HP/UX 11.0, mvwdelch is a block with a return statement
3578 AC_MSG_CHECKING(whether mvwdelch is an expression)
3579 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3580 AC_TRY_COMPILE([#include <curses.h>], [
3582 rtn = mvwdelch(0,0,0);
3583 ], ac_cv_mvwdelch_is_expression=yes,
3584 ac_cv_mvwdelch_is_expression=no,
3585 ac_cv_mvwdelch_is_expression=yes))
3586 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3588 if test "$ac_cv_mvwdelch_is_expression" = yes
3590 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3591 [Define if mvwdelch in curses.h is an expression.])
3594 AC_MSG_CHECKING(whether WINDOW has _flags)
3595 AC_CACHE_VAL(ac_cv_window_has_flags,
3596 AC_TRY_COMPILE([#include <curses.h>], [
3599 ], ac_cv_window_has_flags=yes,
3600 ac_cv_window_has_flags=no,
3601 ac_cv_window_has_flags=no))
3602 AC_MSG_RESULT($ac_cv_window_has_flags)
3605 if test "$ac_cv_window_has_flags" = yes
3607 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3608 [Define if WINDOW in curses.h offers a field _flags.])
3611 AC_MSG_CHECKING(for is_term_resized)
3612 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3613 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3618 AC_MSG_CHECKING(for resize_term)
3619 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3620 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3625 AC_MSG_CHECKING(for resizeterm)
3626 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3627 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3632 AC_MSG_CHECKING(for /dev/ptmx)
3634 if test -r /dev/ptmx
3637 AC_DEFINE(HAVE_DEV_PTMX, 1,
3638 [Define if we have /dev/ptmx.])
3643 AC_MSG_CHECKING(for /dev/ptc)
3648 AC_DEFINE(HAVE_DEV_PTC, 1,
3649 [Define if we have /dev/ptc.])
3654 AC_MSG_CHECKING(for %zd printf() format support)
3655 AC_TRY_RUN([#include <stdio.h>
3659 #ifdef HAVE_SYS_TYPES_H
3660 #include <sys/types.h>
3664 typedef ssize_t Py_ssize_t;
3665 #elif SIZEOF_VOID_P == SIZEOF_LONG
3666 typedef long Py_ssize_t;
3668 typedef int Py_ssize_t;
3675 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3678 if (strcmp(buffer, "123"))
3681 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3684 if (strcmp(buffer, "-123"))
3690 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3693 AC_CHECK_TYPE(socklen_t,,
3694 AC_DEFINE(socklen_t,int,
3695 Define to `int' if <sys/socket.h> does not define.),[
3696 #ifdef HAVE_SYS_TYPES_H
3697 #include <sys/types.h>
3699 #ifdef HAVE_SYS_SOCKET_H
3700 #include <sys/socket.h>
3704 AC_MSG_CHECKING(for broken mbstowcs)
3709 const char *str = "text";
3710 len = mbstowcs(NULL, str, 0);
3714 ac_cv_broken_mbstowcs=no,
3715 ac_cv_broken_mbstowcs=yes,
3716 ac_cv_broken_mbstowcs=no)
3717 AC_MSG_RESULT($ac_cv_broken_mbstowcs)
3718 if test "$ac_cv_broken_mbstowcs" = yes
3720 AC_DEFINE(HAVE_BROKEN_MBSTOWCS, 1,
3721 [Define if mbstowcs(NULL, "text", 0) does not return the number of
3722 wide chars that would be converted.])
3725 # Check for --with-computed-gotos
3726 AC_MSG_CHECKING(for --with-computed-gotos)
3727 AC_ARG_WITH(computed-gotos,
3728 AC_HELP_STRING(--with-computed-gotos,
3729 Use computed gotos / threaded dispatch in evaluation loop (not available on all compilers)),
3731 if test "$withval" != no
3733 AC_DEFINE(USE_COMPUTED_GOTOS, 1,
3734 [Define if you want to use computed gotos in ceval.c.])
3736 else AC_MSG_RESULT(no)
3738 [AC_MSG_RESULT(no)])
3741 AC_SUBST(THREADHEADERS)
3743 for h in `(cd $srcdir;echo Python/thread_*.h)`
3745 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3749 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3750 AC_MSG_CHECKING(for build directories)
3751 for dir in $SRCDIRS; do
3752 if test ! -d $dir; then
3758 # generate output files
3759 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3762 echo "creating Modules/Setup"
3763 if test ! -f Modules/Setup
3765 cp $srcdir/Modules/Setup.dist Modules/Setup
3768 echo "creating Modules/Setup.local"
3769 if test ! -f Modules/Setup.local
3771 echo "# Edit this file for local setup changes" >Modules/Setup.local
3774 echo "creating Makefile"
3775 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3776 -s Modules Modules/Setup.config \
3777 Modules/Setup.local Modules/Setup