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.63).
6 # Set VERSION so we only need to edit in one place (i.e., here)
7 m4_define(PYTHON_VERSION, 2.6)
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 This is for stuff that absolutely must end up in pyconfig.h.
16 dnl Please use pyport.h instead, if possible.
22 /* Define the macros needed if on a UnixWare 7.x system. */
23 #if defined(__USLC__) && defined(__SCO_VERSION__)
24 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
27 #endif /*Py_PYCONFIG_H*/
30 # We don't use PACKAGE_ variables, and they cause conflicts
31 # with other autoconf-based packages that include Python.h
32 grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
34 mv confdefs.h.new confdefs.h
37 VERSION=PYTHON_VERSION
42 # The later defininition of _XOPEN_SOURCE disables certain features
43 # on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
44 AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])
46 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
47 # certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
49 AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])
51 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
52 # certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
54 AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])
56 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
57 # u_int on Irix 5.3. Defining _BSD_TYPES brings it back.
58 AC_DEFINE(_BSD_TYPES, 1, [Define on Irix to enable u_int])
60 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
61 # certain features on Mac OS X, so we need _DARWIN_C_SOURCE to re-enable
63 AC_DEFINE(_DARWIN_C_SOURCE, 1, [Define on Darwin to activate all library features])
66 define_xopen_source=yes
68 # Arguments passed to configure.
70 CONFIG_ARGS="$ac_configure_args"
72 AC_ARG_ENABLE(universalsdk,
73 AC_HELP_STRING(--enable-universalsdk@<:@=SDKDIR@:>@, Build against Mac OS X 10.4u SDK (ppc/i386)),
77 enableval=/Developer/SDKs/MacOSX10.4u.sdk
86 UNIVERSALSDK=$enableval
93 AC_SUBST(UNIVERSALSDK)
96 AC_SUBST(ARCH_RUN_32BIT)
98 UNIVERSAL_ARCHS="32-bit"
99 AC_MSG_CHECKING(for --with-universal-archs)
100 AC_ARG_WITH(universal-archs,
101 AC_HELP_STRING(--with-universal-archs=ARCH, select architectures for universal build ("32-bit", "64-bit" or "all")),
103 AC_MSG_RESULT($withval)
104 UNIVERSAL_ARCHS="$withval"
107 AC_MSG_RESULT(32-bit)
112 AC_ARG_WITH(framework-name,
113 AC_HELP_STRING(--with-framework-name=FRAMEWORK,
114 specify an alternate name of the framework built with --enable-framework),
116 PYTHONFRAMEWORK=${withval}
117 PYTHONFRAMEWORKDIR=${withval}.framework
118 PYTHONFRAMEWORKIDENTIFIER=org.python.`echo $withval | tr '[A-Z]' '[a-z]'`
120 PYTHONFRAMEWORK=Python
121 PYTHONFRAMEWORKDIR=Python.framework
122 PYTHONFRAMEWORKIDENTIFIER=org.python.python
124 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
125 AC_ARG_ENABLE(framework,
126 AC_HELP_STRING(--enable-framework@<:@=INSTALLDIR@:>@, Build (MacOSX|Darwin) framework),
130 enableval=/Library/Frameworks
135 PYTHONFRAMEWORKDIR=no-framework
136 PYTHONFRAMEWORKPREFIX=
137 PYTHONFRAMEWORKINSTALLDIR=
138 FRAMEWORKINSTALLFIRST=
139 FRAMEWORKINSTALLLAST=
140 FRAMEWORKALTINSTALLFIRST=
141 FRAMEWORKALTINSTALLLAST=
142 if test "x${prefix}" = "xNONE"; then
143 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
145 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
150 PYTHONFRAMEWORKPREFIX=$enableval
151 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
152 FRAMEWORKINSTALLFIRST="frameworkinstallstructure"
153 FRAMEWORKALTINSTALLFIRST="frameworkinstallstructure bininstall maninstall"
154 if test "$UNIVERSAL_ARCHS" = "all"
156 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps4way frameworkinstallunixtools4way"
158 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkaltinstallunixtools"
161 if test "x${prefix}" = "xNONE" ; then
162 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
164 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
166 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
168 # Add files for Mac specific code to the list of output
170 AC_CONFIG_FILES(Mac/Makefile)
171 AC_CONFIG_FILES(Mac/PythonLauncher/Makefile)
172 AC_CONFIG_FILES(Mac/IDLE/Makefile)
173 AC_CONFIG_FILES(Mac/Resources/framework/Info.plist)
174 AC_CONFIG_FILES(Mac/Resources/app/Info.plist)
178 PYTHONFRAMEWORKDIR=no-framework
179 PYTHONFRAMEWORKPREFIX=
180 PYTHONFRAMEWORKINSTALLDIR=
181 FRAMEWORKINSTALLFIRST=
182 FRAMEWORKINSTALLLAST=
183 FRAMEWORKALTINSTALLFIRST=
184 FRAMEWORKALTINSTALLLAST=
185 if test "x${prefix}" = "xNONE" ; then
186 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
188 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
192 if test "$UNIVERSAL_ARCHS" = "all"
194 FRAMEWORKINSTALLLAST=update4wayuniversal
195 FRAMEWORKALTINSTALLLAST=update4wayuniversal
198 AC_SUBST(PYTHONFRAMEWORK)
199 AC_SUBST(PYTHONFRAMEWORKIDENTIFIER)
200 AC_SUBST(PYTHONFRAMEWORKDIR)
201 AC_SUBST(PYTHONFRAMEWORKPREFIX)
202 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
203 AC_SUBST(FRAMEWORKINSTALLFIRST)
204 AC_SUBST(FRAMEWORKINSTALLLAST)
205 AC_SUBST(FRAMEWORKALTINSTALLFIRST)
206 AC_SUBST(FRAMEWORKALTINSTALLLAST)
207 AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX)
210 ## AC_HELP_STRING(--with-dyld,
211 ## Use (OpenStep|Rhapsody) dynamic linker))
213 # Set name for machine-dependent library files
215 AC_MSG_CHECKING(MACHDEP)
216 if test -z "$MACHDEP"
218 ac_sys_system=`uname -s`
219 if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64" \
220 -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
221 ac_sys_release=`uname -v`
223 ac_sys_release=`uname -r`
225 ac_md_system=`echo $ac_sys_system |
226 tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
227 ac_md_release=`echo $ac_sys_release |
228 tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
229 MACHDEP="$ac_md_system$ac_md_release"
232 cygwin*) MACHDEP="cygwin";;
233 darwin*) MACHDEP="darwin";;
234 atheos*) MACHDEP="atheos";;
235 irix646) MACHDEP="irix6";;
236 '') MACHDEP="unknown";;
240 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
241 # disable features if it is defined, without any means to access these
242 # features as extensions. For these systems, we skip the definition of
243 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
244 # some feature, make sure there is no alternative way to access this
245 # feature. Also, when using wildcards, make sure you have verified the
246 # need for not defining _XOPEN_SOURCE on all systems matching the
247 # wildcard, and that the wildcard does not include future systems
248 # (which may remove their limitations).
249 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
250 case $ac_sys_system/$ac_sys_release in
251 # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
252 # even though select is a POSIX function. Reported by J. Ribbens.
253 # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
255 define_xopen_source=no
256 # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
257 # also defined. This can be overridden by defining _BSD_SOURCE
258 # As this has a different meaning on Linux, only define it on OpenBSD
259 AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
260 # OpenBSD's readline library needs the libcurses
261 READLINE_LIBS="-lcurses"
263 # Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
264 # _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
266 NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6[A-S])
267 define_xopen_source=no;;
268 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
269 # of union __?sigval. Reported by Stuart Bishop.
271 define_xopen_source=no;;
272 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
273 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
274 # Reconfirmed for 7.1.4 by Martin v. Loewis.
275 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
276 define_xopen_source=no;;
277 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
278 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
280 define_xopen_source=no;;
281 # On FreeBSD 4.8 and MacOS X 10.2, a bug in ncurses.h means that
282 # it craps out if _XOPEN_EXTENDED_SOURCE is defined. Apparently,
283 # this is fixed in 10.3, which identifies itself as Darwin/7.*
284 # This should hopefully be fixed in FreeBSD 4.9
285 FreeBSD/4.8* | Darwin/6* )
286 define_xopen_source=no;;
287 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
288 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
289 # or has another value. By not (re)defining it, the defaults come in place.
291 define_xopen_source=no;;
293 if test `uname -r` -eq 1; then
294 define_xopen_source=no
297 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
298 # disables platform specific features beyond repair.
299 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
300 # has no effect, don't bother defining them
301 Darwin/@<:@789@:>@.*)
302 define_xopen_source=no
304 # On QNX 6.3.2, defining _XOPEN_SOURCE prevents netdb.h from
305 # defining NI_NUMERICHOST.
307 define_xopen_source=no
312 if test $define_xopen_source = yes
314 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
315 # defined precisely as g++ defines it
316 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
318 case $ac_sys_system/$ac_sys_release in
319 SunOS/5.8|SunOS/5.9|SunOS/5.10)
320 AC_DEFINE(_XOPEN_SOURCE, 500,
321 Define to the level of X/Open that your system supports)
324 AC_DEFINE(_XOPEN_SOURCE, 600,
325 Define to the level of X/Open that your system supports)
329 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
330 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
331 # several APIs are not declared. Since this is also needed in some
332 # cases for HP-UX, we define it globally.
333 # except for Solaris 10, where it must not be defined,
334 # as it implies XPG4.2
335 case $ac_sys_system/$ac_sys_release in
339 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
340 Define to activate Unix95-and-earlier features)
344 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
349 # SGI compilers allow the specification of the both the ABI and the
350 # ISA on the command line. Depending on the values of these switches,
351 # different and often incompatable code will be generated.
353 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
354 # thus supply support for various ABI/ISA combinations. The MACHDEP
355 # variable is also adjusted.
358 if test ! -z "$SGI_ABI"
361 LDFLAGS="$SGI_ABI $LDFLAGS"
362 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
364 AC_MSG_RESULT($MACHDEP)
366 # And add extra plat-mac for darwin
367 AC_SUBST(EXTRAPLATDIR)
368 AC_SUBST(EXTRAMACHDEPPATH)
369 AC_MSG_CHECKING(EXTRAPLATDIR)
370 if test -z "$EXTRAPLATDIR"
374 EXTRAPLATDIR="\$(PLATMACDIRS)"
375 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
383 AC_MSG_RESULT($EXTRAPLATDIR)
385 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
386 # it may influence the way we can build extensions, so distutils
388 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
389 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
390 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
391 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
393 AC_MSG_CHECKING(machine type as reported by uname -m)
394 ac_sys_machine=`uname -m`
395 AC_MSG_RESULT($ac_sys_machine)
397 # checks for alternative programs
399 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
400 # for debug/optimization stuff. BASECFLAGS is for flags that are required
401 # just to get things to compile and link. Users are free to override OPT
402 # when running configure or make. The build should not break if they do.
403 # BASECFLAGS should generally not be messed with, however.
405 # XXX shouldn't some/most/all of this code be merged with the stuff later
406 # on that fiddles with OPT and BASECFLAGS?
407 AC_MSG_CHECKING(for --without-gcc)
409 AC_HELP_STRING(--without-gcc,never use gcc),
417 without_gcc=$withval;;
419 case $ac_sys_system in
427 BASECFLAGS="$BASECFLAGS -export pragma"
429 LDFLAGS="$LDFLAGS -nodup"
437 AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
440 AR="\$(srcdir)/Modules/ar_beos"
448 AC_MSG_RESULT($without_gcc)
450 # If the user switches compilers, we can't believe the cache
451 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
453 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
454 (it is also a good idea to do 'make clean' before compiling)])
461 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
462 AC_ARG_WITH(cxx_main,
463 AC_HELP_STRING([--with-cxx-main=<compiler>],
464 [compile main() and link python executable with C++ compiler]),
470 yes) with_cxx_main=yes
482 AC_MSG_RESULT($with_cxx_main)
488 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
489 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
491 if test "$CXX" = "notfound"
498 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
499 if test "$CXX" = "notfound"
504 if test "$preset_cxx" != "$CXX"
508 By default, distutils will build C++ extension modules with "$CXX".
509 If this is not intended, then set CXX on the configure command line.
514 # checks for UNIX variants that set C preprocessor variables
517 # Check for unsupported systems
518 case $ac_sys_system/$ac_sys_release in
520 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
521 echo See README for details.
526 AC_MSG_CHECKING(for --with-suffix)
528 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
535 AC_MSG_RESULT($EXEEXT)
537 # Test whether we're running on a non-case-sensitive system, in which
538 # case we give a warning if no ext is given
539 AC_SUBST(BUILDEXEEXT)
540 AC_MSG_CHECKING(for case-insensitive build directory)
541 if test ! -d CaseSensitiveTestDir; then
542 mkdir CaseSensitiveTestDir
545 if test -d casesensitivetestdir
553 rmdir CaseSensitiveTestDir
558 gcc) CC="$CC -D_HAVE_BSDI";;
562 case $ac_sys_system in
565 cc|*/cc) CC="$CC -Ae";;
569 cc) CC="$CC -Wl,-Bexport";;
572 # Some functions have a prototype only with that define, e.g. confstr
573 AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
579 AC_MSG_CHECKING(LIBRARY)
580 if test -z "$LIBRARY"
582 LIBRARY='libpython$(VERSION).a'
584 AC_MSG_RESULT($LIBRARY)
586 # LDLIBRARY is the name of the library to link against (as opposed to the
587 # name of the library into which to insert object files). BLDLIBRARY is also
588 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
589 # is blank as the main program is not linked directly against LDLIBRARY.
590 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
591 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
592 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
593 # DLLLIBRARY is the shared (i.e., DLL) library.
595 # RUNSHARED is used to run shared python without installed libraries
597 # INSTSONAME is the name of the shared library that will be use to install
598 # on the system - some systems like version suffix, others don't
602 AC_SUBST(LDLIBRARYDIR)
606 BLDLIBRARY='$(LDLIBRARY)'
607 INSTSONAME='$(LDLIBRARY)'
612 # LINKCC is the command that links the python executable -- default is $(CC).
613 # If CXX is set, and if it is needed to link a main function that was
614 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
615 # python might then depend on the C++ runtime
616 # This is altered for AIX in order to build the export list before
619 AC_MSG_CHECKING(LINKCC)
622 LINKCC='$(PURIFY) $(MAINCC)'
623 case $ac_sys_system in
626 if test $ac_sys_release -ge 5 -o \
627 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
630 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
632 LINKCC="$LINKCC -L/usr/lib/ia64l64";;
634 # qcc must be used because the other compilers do not
639 AC_MSG_RESULT($LINKCC)
641 AC_MSG_CHECKING(for --enable-shared)
642 AC_ARG_ENABLE(shared,
643 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
645 if test -z "$enable_shared"
647 case $ac_sys_system in
649 enable_shared="yes";;
654 AC_MSG_RESULT($enable_shared)
656 AC_MSG_CHECKING(for --enable-profiling)
657 AC_ARG_ENABLE(profiling,
658 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
661 AC_TRY_RUN([int main() { return 0; }],
662 ac_enable_profiling="yes",
663 ac_enable_profiling="no",
664 ac_enable_profiling="no")
666 AC_MSG_RESULT($ac_enable_profiling)
668 case "$ac_enable_profiling" in
670 BASECFLAGS="-pg $BASECFLAGS"
671 LDFLAGS="-pg $LDFLAGS"
675 AC_MSG_CHECKING(LDLIBRARY)
677 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
678 # library that we build, but we do not want to link against it (we
679 # will find it with a -framework option). For this reason there is an
680 # extra variable BLDLIBRARY against which Python and the extension
681 # modules are linked, BLDLIBRARY. This is normally the same as
682 # LDLIBRARY, but empty for MacOSX framework builds.
683 if test "$enable_framework"
685 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
686 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
689 BLDLIBRARY='$(LDLIBRARY)'
692 # Other platforms follow
693 if test $enable_shared = "yes"; then
694 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
695 case $ac_sys_system in
697 LDLIBRARY='libpython$(VERSION).so'
700 LDLIBRARY='libpython$(VERSION).dll.a'
701 DLLLIBRARY='libpython$(VERSION).dll'
704 LDLIBRARY='libpython$(VERSION).so'
705 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
706 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
707 INSTSONAME="$LDLIBRARY".$SOVERSION
709 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
710 LDLIBRARY='libpython$(VERSION).so'
711 BLDLIBRARY='-L. -lpython$(VERSION)'
712 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
713 case $ac_sys_system in
715 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
718 INSTSONAME="$LDLIBRARY".$SOVERSION
723 LDLIBRARY='libpython$(VERSION).so'
726 LDLIBRARY='libpython$(VERSION).sl'
729 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
730 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
733 LDLIBRARY='libpython$(VERSION).so'
734 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
735 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
738 LDLIBRARY='libpython$(VERSION).so'
739 BLDLIBRARY='-L. -lpython$(VERSION)'
740 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
743 else # shared is disabled
744 case $ac_sys_system in
746 BLDLIBRARY='$(LIBRARY)'
747 LDLIBRARY='libpython$(VERSION).dll.a'
752 AC_MSG_RESULT($LDLIBRARY)
756 AC_CHECK_PROGS(AR, ar aal, ar)
759 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
760 if test $SVNVERSION = found
762 SVNVERSION="svnversion \$(srcdir)"
764 SVNVERSION="echo exported"
769 # install -d does not work on BSDI or HP-UX
770 if test -z "$INSTALL"
772 INSTALL="${srcdir}/install-sh -c"
777 # Not every filesystem supports hard links
779 if test -z "$LN" ; then
780 case $ac_sys_system in
782 CYGWIN*) LN="ln -s";;
783 atheos*) LN="ln -s";;
788 # Check for --with-pydebug
789 AC_MSG_CHECKING(for --with-pydebug)
791 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
793 if test "$withval" != no
795 AC_DEFINE(Py_DEBUG, 1,
796 [Define if you want to build an interpreter with many run-time checks.])
799 else AC_MSG_RESULT(no); Py_DEBUG='false'
803 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
804 # merged with this chunk of code?
806 # Optimizer/debugger flags
807 # ------------------------
808 # (The following bit of code is complicated enough - please keep things
809 # indented properly. Just pretend you're editing Python code. ;-)
811 # There are two parallel sets of case statements below, one that checks to
812 # see if OPT was set and one that does BASECFLAGS setting based upon
813 # compiler and platform. BASECFLAGS tweaks need to be made even if the
816 # tweak OPT based on compiler and platform, only if the user didn't set
817 # it on the command line
823 if test "$CC" != 'g++' ; then
824 STRICT_PROTO="-Wstrict-prototypes"
826 # For gcc 4.x we need to use -fwrapv so lets check if its supported
827 if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
830 case $ac_cv_prog_cc_g in
832 if test "$Py_DEBUG" = 'true' ; then
833 # Optimization messes up debuggers, so turn it off for
835 OPT="-g -Wall $STRICT_PROTO"
837 OPT="-g $WRAP -O3 -Wall $STRICT_PROTO"
841 OPT="-O3 -Wall $STRICT_PROTO"
844 case $ac_sys_system in
845 SCO_SV*) OPT="$OPT -m486 -DSCO5"
855 # The current (beta) Monterey compiler dies with optimizations
856 # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
857 case $ac_sys_system in
867 # The -arch flags for universal builds on OSX
868 UNIVERSAL_ARCH_FLAGS=
869 AC_SUBST(UNIVERSAL_ARCH_FLAGS)
871 # tweak BASECFLAGS based on compiler and platform
874 # Python violates C99 rules, by casting between incompatible
875 # pointer types. GCC may generate bad code as a result of that,
876 # so use -fno-strict-aliasing if supported.
877 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
879 CC="$CC -fno-strict-aliasing"
880 AC_TRY_RUN([int main() { return 0; }],
881 ac_cv_no_strict_aliasing_ok=yes,
882 ac_cv_no_strict_aliasing_ok=no,
883 ac_cv_no_strict_aliasing_ok=no)
885 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
886 if test $ac_cv_no_strict_aliasing_ok = yes
888 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
891 # if using gcc on alpha, use -mieee to get (near) full IEEE 754
892 # support. Without this, treatment of subnormals doesn't follow
894 case $ac_sys_machine in
896 BASECFLAGS="$BASECFLAGS -mieee"
900 case $ac_sys_system in
902 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
904 # is there any other compiler on Darwin besides gcc?
906 # -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
907 # used to be here, but non-Apple gcc doesn't accept them.
910 if test "${enable_universalsdk}"; then
911 UNIVERSAL_ARCH_FLAGS=""
912 if test "$UNIVERSAL_ARCHS" = "32-bit" ; then
913 UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386"
916 elif test "$UNIVERSAL_ARCHS" = "64-bit" ; then
917 UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64"
919 elif test "$UNIVERSAL_ARCHS" = "all" ; then
920 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64"
921 ARCH_RUN_32BIT="arch -i386 -ppc"
924 AC_MSG_ERROR([proper usage is --with-universalarch=32-bit|64-bit|all])
929 BASECFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
930 tgt=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
931 if test "${UNIVERSALSDK}" != "/" -a "${tgt}" '>' '10.4' ; then
932 CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
936 # Calculate the right deployment target for this build.
938 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
939 if test ${cur_target} '>' 10.2; then
942 if test "${UNIVERSAL_ARCHS}" = "all"; then
943 # Ensure that the default platform for a 4-way
944 # universal build is OSX 10.5, that's the first
945 # OS release where 4-way builds make sense.
948 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
950 # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
951 # environment with a value that is the same as what we'll use
952 # in the Makefile to ensure that we'll get the same compiler
953 # environment during configure and build time.
954 MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
955 export MACOSX_DEPLOYMENT_TARGET
956 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
960 BASECFLAGS="$BASECFLAGS -mieee"
966 case $ac_sys_system in
968 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
971 BASECFLAGS="$BASECFLAGS -ieee -std"
974 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
980 if test "$Py_DEBUG" = 'true'; then
986 if test "$ac_arch_flags"
988 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
991 # disable check for icc since it seems to pass, but generates a warning
994 ac_cv_opt_olimit_ok=no
997 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
998 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
1000 CC="$CC -OPT:Olimit=0"
1001 AC_TRY_RUN([int main() { return 0; }],
1002 ac_cv_opt_olimit_ok=yes,
1003 ac_cv_opt_olimit_ok=no,
1004 ac_cv_opt_olimit_ok=no)
1006 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
1007 if test $ac_cv_opt_olimit_ok = yes; then
1008 case $ac_sys_system in
1009 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
1010 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
1015 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
1019 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
1020 AC_CACHE_VAL(ac_cv_olimit_ok,
1022 CC="$CC -Olimit 1500"
1023 AC_TRY_RUN([int main() { return 0; }],
1024 ac_cv_olimit_ok=yes,
1028 AC_MSG_RESULT($ac_cv_olimit_ok)
1029 if test $ac_cv_olimit_ok = yes; then
1030 BASECFLAGS="$BASECFLAGS -Olimit 1500"
1034 # Check whether GCC supports PyArg_ParseTuple format
1035 if test "$GCC" = "yes"
1037 AC_MSG_CHECKING(whether gcc supports ParseTuple __format__)
1039 CFLAGS="$CFLAGS -Werror"
1041 void f(char*,...)__attribute((format(PyArg_ParseTuple, 1, 2)));
1043 AC_DEFINE(HAVE_ATTRIBUTE_FORMAT_PARSETUPLE, 1, [Define if GCC supports __attribute__((format(PyArg_ParseTuple, 2, 3)))])
1050 # On some compilers, pthreads are available without further options
1051 # (e.g. MacOS X). On some of these systems, the compiler will not
1052 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
1053 # So we have to see first whether pthreads are available without
1054 # options before we can check whether -Kpthread improves anything.
1055 AC_MSG_CHECKING(whether pthreads are available without options)
1056 AC_CACHE_VAL(ac_cv_pthread_is_default,
1058 #include <pthread.h>
1060 void* routine(void* p){return NULL;}
1064 if(pthread_create(&p,NULL,routine,NULL)!=0)
1066 (void)pthread_detach(p);
1071 ac_cv_pthread_is_default=yes
1075 ac_cv_pthread_is_default=no,
1076 ac_cv_pthread_is_default=no)
1078 AC_MSG_RESULT($ac_cv_pthread_is_default)
1081 if test $ac_cv_pthread_is_default = yes
1085 # -Kpthread, if available, provides the right #defines
1086 # and linker options to make pthread_create available
1087 # Some compilers won't report that they do not support -Kpthread,
1088 # so we need to run a program to see whether it really made the
1089 # function available.
1090 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
1091 AC_CACHE_VAL(ac_cv_kpthread,
1095 #include <pthread.h>
1097 void* routine(void* p){return NULL;}
1101 if(pthread_create(&p,NULL,routine,NULL)!=0)
1103 (void)pthread_detach(p);
1111 AC_MSG_RESULT($ac_cv_kpthread)
1114 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
1116 # -Kthread, if available, provides the right #defines
1117 # and linker options to make pthread_create available
1118 # Some compilers won't report that they do not support -Kthread,
1119 # so we need to run a program to see whether it really made the
1120 # function available.
1121 AC_MSG_CHECKING(whether $CC accepts -Kthread)
1122 AC_CACHE_VAL(ac_cv_kthread,
1126 #include <pthread.h>
1128 void* routine(void* p){return NULL;}
1132 if(pthread_create(&p,NULL,routine,NULL)!=0)
1134 (void)pthread_detach(p);
1142 AC_MSG_RESULT($ac_cv_kthread)
1145 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
1147 # -pthread, if available, provides the right #defines
1148 # and linker options to make pthread_create available
1149 # Some compilers won't report that they do not support -pthread,
1150 # so we need to run a program to see whether it really made the
1151 # function available.
1152 AC_MSG_CHECKING(whether $CC accepts -pthread)
1153 AC_CACHE_VAL(ac_cv_thread,
1157 #include <pthread.h>
1159 void* routine(void* p){return NULL;}
1163 if(pthread_create(&p,NULL,routine,NULL)!=0)
1165 (void)pthread_detach(p);
1173 AC_MSG_RESULT($ac_cv_pthread)
1176 # If we have set a CC compiler flag for thread support then
1177 # check if it works for CXX, too.
1181 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1184 if test "$ac_cv_kpthread" = "yes"
1186 CXX="$CXX -Kpthread"
1187 ac_cv_cxx_thread=yes
1188 elif test "$ac_cv_kthread" = "yes"
1191 ac_cv_cxx_thread=yes
1192 elif test "$ac_cv_pthread" = "yes"
1195 ac_cv_cxx_thread=yes
1198 if test $ac_cv_cxx_thread = yes
1200 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1201 $CXX -c conftest.$ac_ext 2>&5
1202 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1203 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1205 ac_cv_cxx_thread=yes
1211 AC_MSG_RESULT($ac_cv_cxx_thread)
1215 dnl # check for ANSI or K&R ("traditional") preprocessor
1216 dnl AC_MSG_CHECKING(for C preprocessor type)
1217 dnl AC_TRY_COMPILE([
1218 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1220 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1221 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1222 dnl AC_MSG_RESULT($cpp_type)
1224 # checks for header files
1226 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1228 ieeefp.h io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
1229 shadow.h signal.h stdint.h stropts.h termios.h thread.h \
1231 sys/audioio.h sys/bsdtty.h sys/epoll.h sys/event.h sys/file.h sys/loadavg.h \
1232 sys/lock.h sys/mkdev.h sys/modem.h \
1233 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1234 sys/termio.h sys/time.h \
1235 sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1236 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1237 bluetooth/bluetooth.h linux/tipc.h)
1241 # On Solaris, term.h requires curses.h
1242 AC_CHECK_HEADERS(term.h,,,[
1243 #ifdef HAVE_CURSES_H
1248 # On Linux, netlink.h requires asm/types.h
1249 AC_CHECK_HEADERS(linux/netlink.h,,,[
1250 #ifdef HAVE_ASM_TYPES_H
1251 #include <asm/types.h>
1253 #ifdef HAVE_SYS_SOCKET_H
1254 #include <sys/socket.h>
1258 # checks for typedefs
1260 AC_MSG_CHECKING(for clock_t in time.h)
1261 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1262 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1264 AC_MSG_RESULT($was_it_defined)
1266 # Check whether using makedev requires defining _OSF_SOURCE
1267 AC_MSG_CHECKING(for makedev)
1268 AC_TRY_LINK([#include <sys/types.h> ],
1270 ac_cv_has_makedev=yes,
1271 ac_cv_has_makedev=no)
1272 if test "$ac_cv_has_makedev" = "no"; then
1273 # we didn't link, try if _OSF_SOURCE will allow us to link
1275 #define _OSF_SOURCE 1
1276 #include <sys/types.h>
1279 ac_cv_has_makedev=yes,
1280 ac_cv_has_makedev=no)
1281 if test "$ac_cv_has_makedev" = "yes"; then
1282 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1285 AC_MSG_RESULT($ac_cv_has_makedev)
1286 if test "$ac_cv_has_makedev" = "yes"; then
1287 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1290 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1291 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1292 # defined, but the compiler does not support pragma redefine_extname,
1293 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1294 # structures (such as rlimit64) without declaring them. As a
1295 # work-around, disable LFS on such configurations
1298 AC_MSG_CHECKING(Solaris LFS bug)
1300 #define _LARGEFILE_SOURCE 1
1301 #define _FILE_OFFSET_BITS 64
1302 #include <sys/resource.h>
1303 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1304 AC_MSG_RESULT($sol_lfs_bug)
1305 if test "$sol_lfs_bug" = "yes"; then
1309 if test "$use_lfs" = "yes"; then
1310 # Two defines needed to enable largefile support on various platforms
1311 # These may affect some typedefs
1312 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1313 [This must be defined on some systems to enable large file support.])
1314 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1315 [This must be set to 64 on some systems to enable large file support.])
1318 # Add some code to confdefs.h so that the test for off_t works on SCO
1319 cat >> confdefs.h <<\EOF
1325 # Type availability checks
1332 AC_CHECK_TYPE(ssize_t,
1333 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1335 # Sizes of various common basic types
1336 # ANSI C requires sizeof(char) == 1, so no need to check it
1337 AC_CHECK_SIZEOF(int, 4)
1338 AC_CHECK_SIZEOF(long, 4)
1339 AC_CHECK_SIZEOF(void *, 4)
1340 AC_CHECK_SIZEOF(short, 2)
1341 AC_CHECK_SIZEOF(float, 4)
1342 AC_CHECK_SIZEOF(double, 8)
1343 AC_CHECK_SIZEOF(fpos_t, 4)
1344 AC_CHECK_SIZEOF(size_t, 4)
1345 AC_CHECK_SIZEOF(pid_t, 4)
1347 AC_MSG_CHECKING(for long long support)
1349 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1350 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1353 AC_MSG_RESULT($have_long_long)
1354 if test "$have_long_long" = yes ; then
1355 AC_CHECK_SIZEOF(long long, 8)
1358 AC_MSG_CHECKING(for long double support)
1360 AC_TRY_COMPILE([], [long double x; x = (long double)0.;], [
1361 AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define this if you have the type long double.])
1362 have_long_double=yes
1364 AC_MSG_RESULT($have_long_double)
1365 if test "$have_long_double" = yes ; then
1366 AC_CHECK_SIZEOF(long double, 12)
1369 AC_MSG_CHECKING(for _Bool support)
1371 AC_TRY_COMPILE([], [_Bool x; x = (_Bool)0;], [
1372 AC_DEFINE(HAVE_C99_BOOL, 1, [Define this if you have the type _Bool.])
1375 AC_MSG_RESULT($have_c99_bool)
1376 if test "$have_c99_bool" = yes ; then
1377 AC_CHECK_SIZEOF(_Bool, 1)
1380 AC_CHECK_TYPES(uintptr_t,
1381 [AC_CHECK_SIZEOF(uintptr_t, 4)],
1382 [], [#ifdef HAVE_STDINT_H
1387 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1388 AC_MSG_CHECKING(size of off_t)
1389 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1390 [AC_TRY_RUN([#include <stdio.h>
1391 #include <sys/types.h>
1394 FILE *f=fopen("conftestval", "w");
1396 fprintf(f, "%d\n", sizeof(off_t));
1399 ac_cv_sizeof_off_t=`cat conftestval`,
1400 ac_cv_sizeof_off_t=0,
1401 ac_cv_sizeof_off_t=4)
1403 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1404 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1405 [The number of bytes in an off_t.])
1407 AC_MSG_CHECKING(whether to enable large file support)
1408 if test "$have_long_long" = yes -a \
1409 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1410 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1411 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1412 [Defined to enable large file support when an off_t is bigger than a long
1413 and long long is available and at least as big as an off_t. You may need
1414 to add some flags for configuration and compilation to enable this mode.
1415 (For Solaris and Linux, the necessary defines are already defined.)])
1421 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1422 AC_MSG_CHECKING(size of time_t)
1423 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1424 [AC_TRY_RUN([#include <stdio.h>
1428 FILE *f=fopen("conftestval", "w");
1430 fprintf(f, "%d\n", sizeof(time_t));
1433 ac_cv_sizeof_time_t=`cat conftestval`,
1434 ac_cv_sizeof_time_t=0,
1435 ac_cv_sizeof_time_t=4)
1437 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1438 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1439 [The number of bytes in a time_t.])
1442 # if have pthread_t then define SIZEOF_PTHREAD_T
1444 if test "$ac_cv_kpthread" = "yes"
1445 then CC="$CC -Kpthread"
1446 elif test "$ac_cv_kthread" = "yes"
1447 then CC="$CC -Kthread"
1448 elif test "$ac_cv_pthread" = "yes"
1449 then CC="$CC -pthread"
1451 AC_MSG_CHECKING(for pthread_t)
1453 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1454 AC_MSG_RESULT($have_pthread_t)
1455 if test "$have_pthread_t" = yes ; then
1456 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1457 AC_MSG_CHECKING(size of pthread_t)
1458 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1459 [AC_TRY_RUN([#include <stdio.h>
1460 #include <pthread.h>
1463 FILE *f=fopen("conftestval", "w");
1465 fprintf(f, "%d\n", sizeof(pthread_t));
1468 ac_cv_sizeof_pthread_t=`cat conftestval`,
1469 ac_cv_sizeof_pthread_t=0,
1470 ac_cv_sizeof_pthread_t=4)
1472 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1473 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1474 [The number of bytes in a pthread_t.])
1478 AC_MSG_CHECKING(for --enable-toolbox-glue)
1479 AC_ARG_ENABLE(toolbox-glue,
1480 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1482 if test -z "$enable_toolbox_glue"
1484 case $ac_sys_system/$ac_sys_release in
1486 enable_toolbox_glue="yes";;
1488 enable_toolbox_glue="no";;
1491 case "$enable_toolbox_glue" in
1493 extra_machdep_objs="Python/mactoolboxglue.o"
1494 extra_undefs="-u _PyMac_Error"
1495 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1496 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1499 extra_machdep_objs=""
1503 AC_MSG_RESULT($enable_toolbox_glue)
1506 AC_SUBST(OTHER_LIBTOOL_OPT)
1507 case $ac_sys_system/$ac_sys_release in
1508 Darwin/@<:@01567@:>@\..*)
1509 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1512 OTHER_LIBTOOL_OPT=""
1516 AC_SUBST(LIBTOOL_CRUFT)
1517 case $ac_sys_system/$ac_sys_release in
1518 Darwin/@<:@01567@:>@\..*)
1519 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1520 if test "${enable_universalsdk}"; then
1523 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1525 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1526 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1528 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1529 if test ${gcc_version} '<' 4.0
1531 LIBTOOL_CRUFT="-lcc_dynamic"
1535 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1536 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1537 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1540 AC_MSG_CHECKING(for --enable-framework)
1541 if test "$enable_framework"
1543 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1544 # -F. is needed to allow linking to the framework while
1545 # in the build location.
1546 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1547 [Define if you want to produce an OpenStep/Rhapsody framework
1548 (shared library plus accessory files).])
1554 AC_MSG_CHECKING(for dyld)
1555 case $ac_sys_system/$ac_sys_release in
1557 AC_DEFINE(WITH_DYLD, 1,
1558 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1559 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1560 linker (rld). Dyld is necessary to support frameworks.])
1561 AC_MSG_RESULT(always on for Darwin)
1568 # Set info about shared libraries.
1573 AC_SUBST(LINKFORSHARED)
1574 # SO is the extension of shared libraries `(including the dot!)
1575 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1579 case $ac_sys_system in
1590 # this might also be a termcap variable, see #610332
1592 echo '====================================================================='
1594 echo '+ WARNING: You have set SO in your environment. +'
1595 echo '+ Do you really mean to change the extension for shared libraries? +'
1596 echo '+ Continuing in 10 seconds to let you to ponder. +'
1598 echo '====================================================================='
1602 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1603 # LDSHARED is the ld *command* used to create shared library
1604 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1605 # (Shared libraries in this instance are shared modules to be loaded into
1606 # Python, as opposed to building Python itself as a shared library.)
1607 AC_MSG_CHECKING(LDSHARED)
1608 if test -z "$LDSHARED"
1610 case $ac_sys_system/$ac_sys_release in
1612 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1613 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1616 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1617 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1619 IRIX/5*) LDSHARED="ld -shared";;
1620 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1622 if test "$GCC" = "yes"
1623 then LDSHARED='$(CC) -shared'
1624 else LDSHARED='$(CC) -G';
1627 if test "$GCC" = "yes"
1628 then LDSHARED='$(CC) -shared'
1629 else LDSHARED='ld -b';
1631 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1633 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1634 if test "$enable_framework" ; then
1635 # Link against the framework. All externals should be defined.
1636 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1637 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1639 # No framework. Ignore undefined symbols, assuming they come from Python
1640 LDSHARED="$LDSHARED -undefined suppress"
1642 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1643 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1644 if test "$enable_framework" ; then
1645 # Link against the framework. All externals should be defined.
1646 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1647 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1649 # No framework, use the Python app as bundle-loader
1650 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1651 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1654 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1655 # This allows an extension to be used in any Python
1657 if test ${MACOSX_DEPLOYMENT_TARGET} '>' 10.2
1659 if test "${enable_universalsdk}"; then
1660 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1662 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1663 BLDSHARED="$LDSHARED"
1665 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1666 if test "$enable_framework" ; then
1667 # Link against the framework. All externals should be defined.
1668 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1669 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1671 # No framework, use the Python app as bundle-loader
1672 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1673 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1677 Linux*|GNU*|QNX*) LDSHARED='$(CC) -shared';;
1678 BSD/OS*/4*) LDSHARED="gcc -shared";;
1680 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1682 LDSHARED="$CC -shared ${LDFLAGS}"
1684 LDSHARED="ld -Bshareable ${LDFLAGS}"
1687 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1689 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1692 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1693 LDSHARED="ld -Bshareable ${LDFLAGS}"
1696 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1700 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1701 OpenUNIX*|UnixWare*)
1702 if test "$GCC" = "yes"
1703 then LDSHARED='$(CC) -shared'
1704 else LDSHARED='$(CC) -G'
1706 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1707 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1708 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1709 atheos*) LDSHARED="gcc -shared";;
1713 AC_MSG_RESULT($LDSHARED)
1714 BLDSHARED=${BLDSHARED-$LDSHARED}
1715 # CCSHARED are the C *flags* used to create objects to go into a shared
1716 # library (module) -- this is only needed for a few systems
1717 AC_MSG_CHECKING(CCSHARED)
1718 if test -z "$CCSHARED"
1720 case $ac_sys_system/$ac_sys_release in
1721 SunOS*) if test "$GCC" = yes;
1722 then CCSHARED="-fPIC";
1723 elif test `uname -p` = sparc;
1724 then CCSHARED="-xcode=pic32";
1725 else CCSHARED="-Kpic";
1727 hp*|HP*) if test "$GCC" = yes;
1728 then CCSHARED="-fPIC";
1731 Linux*|GNU*) CCSHARED="-fPIC";;
1732 BSD/OS*/4*) CCSHARED="-fpic";;
1733 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1734 OpenUNIX*|UnixWare*)
1735 if test "$GCC" = "yes"
1736 then CCSHARED="-fPIC"
1737 else CCSHARED="-KPIC"
1740 if test "$GCC" = "yes"
1741 then CCSHARED="-fPIC"
1742 else CCSHARED="-Kpic -belf"
1744 Monterey*) CCSHARED="-G";;
1745 IRIX*/6*) case $CC in
1746 *gcc*) CCSHARED="-shared";;
1749 atheos*) CCSHARED="-fPIC";;
1752 AC_MSG_RESULT($CCSHARED)
1753 # LINKFORSHARED are the flags passed to the $(CC) command that links
1754 # the python executable -- this is only needed for a few systems
1755 AC_MSG_CHECKING(LINKFORSHARED)
1756 if test -z "$LINKFORSHARED"
1758 case $ac_sys_system/$ac_sys_release in
1759 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1761 LINKFORSHARED="-Wl,-E -Wl,+s";;
1762 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1763 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1764 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1765 # -u libsys_s pulls in all symbols in libsys
1767 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1769 # not used by the core itself but which needs to be in the core so
1770 # that dynamically loaded extension modules have access to it.
1771 # -prebind is no longer used, because it actually seems to give a
1772 # slowdown in stead of a speedup, maybe due to the large number of
1773 # dynamic loads Python does.
1775 LINKFORSHARED="$extra_undefs"
1776 if test "$enable_framework"
1778 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1780 LINKFORSHARED="$LINKFORSHARED";;
1781 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1782 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1783 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1784 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1785 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1787 LINKFORSHARED="-Wl,--export-dynamic"
1789 SunOS/5*) case $CC in
1791 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1793 LINKFORSHARED="-Xlinker --export-dynamic"
1797 if test $enable_shared = "no"
1799 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1802 # -Wl,-E causes the symbols to be added to the dynamic
1803 # symbol table so that they can be found when a module
1804 # is loaded. -N 2048K causes the stack size to be set
1805 # to 2048 kilobytes so that the stack doesn't overflow
1806 # when running test_compile.py.
1807 LINKFORSHARED='-Wl,-E -N 2048K';;
1810 AC_MSG_RESULT($LINKFORSHARED)
1813 AC_SUBST(CFLAGSFORSHARED)
1814 AC_MSG_CHECKING(CFLAGSFORSHARED)
1815 if test ! "$LIBRARY" = "$LDLIBRARY"
1817 case $ac_sys_system in
1819 # Cygwin needs CCSHARED when building extension DLLs
1820 # but not when building the interpreter DLL.
1821 CFLAGSFORSHARED='';;
1823 CFLAGSFORSHARED='$(CCSHARED)'
1826 AC_MSG_RESULT($CFLAGSFORSHARED)
1828 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1829 # library (with --enable-shared).
1830 # For platforms on which shared libraries are not allowed to have unresolved
1831 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1832 # if it is not required, since it creates a dependency of the shared library
1833 # to LIBS. This, in turn, means that applications linking the shared libpython
1834 # don't need to link LIBS explicitly. The default should be only changed
1835 # on systems where this approach causes problems.
1837 AC_MSG_CHECKING(SHLIBS)
1838 case "$ac_sys_system" in
1842 AC_MSG_RESULT($SHLIBS)
1845 # checks for libraries
1846 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1847 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1849 # only check for sem_ini if thread support is requested
1850 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1851 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1852 # posix4 on Solaris 2.6
1853 # pthread (first!) on Linux
1856 # check if we need libintl for locale functions
1857 AC_CHECK_LIB(intl, textdomain,
1858 AC_DEFINE(WITH_LIBINTL, 1,
1859 [Define to 1 if libintl is needed for locale functions.]))
1861 # checks for system dependent C++ extensions support
1862 case "$ac_sys_system" in
1863 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1864 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1865 [loadAndInit("", 0, "")],
1866 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1867 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1868 and you want support for AIX C++ shared extension modules.])
1869 AC_MSG_RESULT(yes)],
1870 [AC_MSG_RESULT(no)]);;
1874 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1875 # BeOS' sockets are stashed in libnet.
1876 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1877 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1879 case "$ac_sys_system" in
1881 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1885 AC_MSG_CHECKING(for --with-libs)
1887 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1889 AC_MSG_RESULT($withval)
1890 LIBS="$withval $LIBS"
1892 [AC_MSG_RESULT(no)])
1894 # Check for use of the system libffi library
1895 AC_MSG_CHECKING(for --with-system-ffi)
1896 AC_ARG_WITH(system_ffi,
1897 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1899 AC_MSG_RESULT($with_system_ffi)
1901 # Determine if signalmodule should be used.
1902 AC_SUBST(USE_SIGNAL_MODULE)
1903 AC_SUBST(SIGNAL_OBJS)
1904 AC_MSG_CHECKING(for --with-signal-module)
1905 AC_ARG_WITH(signal-module,
1906 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1908 if test -z "$with_signal_module"
1909 then with_signal_module="yes"
1911 AC_MSG_RESULT($with_signal_module)
1913 if test "${with_signal_module}" = "yes"; then
1914 USE_SIGNAL_MODULE=""
1917 USE_SIGNAL_MODULE="#"
1918 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1921 # This is used to generate Setup.config
1922 AC_SUBST(USE_THREAD_MODULE)
1923 USE_THREAD_MODULE=""
1925 AC_MSG_CHECKING(for --with-dec-threads)
1927 AC_ARG_WITH(dec-threads,
1928 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1930 AC_MSG_RESULT($withval)
1932 if test "${with_thread+set}" != set; then
1933 with_thread="$withval";
1935 [AC_MSG_RESULT(no)])
1937 # Templates for things AC_DEFINEd more than once.
1938 # For a single AC_DEFINE, no template is needed.
1939 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1940 AH_TEMPLATE(_REENTRANT,
1941 [Define to force use of thread-safe errno, h_errno, and other functions])
1942 AH_TEMPLATE(WITH_THREAD,
1943 [Define if you want to compile in rudimentary thread support])
1945 AC_MSG_CHECKING(for --with-threads)
1946 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1947 AC_ARG_WITH(threads,
1948 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1950 # --with-thread is deprecated, but check for it anyway
1951 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1953 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1954 [with_threads=$with_thread])
1956 if test -z "$with_threads"
1957 then with_threads="yes"
1959 AC_MSG_RESULT($with_threads)
1962 if test "$with_threads" = "no"
1964 USE_THREAD_MODULE="#"
1965 elif test "$ac_cv_pthread_is_default" = yes
1967 AC_DEFINE(WITH_THREAD)
1968 # Defining _REENTRANT on system with POSIX threads should not hurt.
1969 AC_DEFINE(_REENTRANT)
1971 THREADOBJ="Python/thread.o"
1972 elif test "$ac_cv_kpthread" = "yes"
1975 if test "$ac_cv_cxx_thread" = "yes"; then
1976 CXX="$CXX -Kpthread"
1978 AC_DEFINE(WITH_THREAD)
1980 THREADOBJ="Python/thread.o"
1981 elif test "$ac_cv_kthread" = "yes"
1984 if test "$ac_cv_cxx_thread" = "yes"; then
1987 AC_DEFINE(WITH_THREAD)
1989 THREADOBJ="Python/thread.o"
1990 elif test "$ac_cv_pthread" = "yes"
1993 if test "$ac_cv_cxx_thread" = "yes"; then
1996 AC_DEFINE(WITH_THREAD)
1998 THREADOBJ="Python/thread.o"
2000 if test ! -z "$with_threads" -a -d "$with_threads"
2001 then LDFLAGS="$LDFLAGS -L$with_threads"
2003 if test ! -z "$withval" -a -d "$withval"
2004 then LDFLAGS="$LDFLAGS -L$withval"
2007 # According to the POSIX spec, a pthreads implementation must
2008 # define _POSIX_THREADS in unistd.h. Some apparently don't
2009 # (e.g. gnu pth with pthread emulation)
2010 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
2014 #ifdef _POSIX_THREADS
2017 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
2018 AC_MSG_RESULT($unistd_defines_pthreads)
2020 AC_DEFINE(_REENTRANT)
2021 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
2022 AC_DEFINE(C_THREADS)
2023 AC_DEFINE(HURD_C_THREADS, 1,
2024 [Define if you are using Mach cthreads directly under /include])
2025 LIBS="$LIBS -lthreads"
2026 THREADOBJ="Python/thread.o"],[
2027 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
2028 AC_DEFINE(C_THREADS)
2029 AC_DEFINE(MACH_C_THREADS, 1,
2030 [Define if you are using Mach cthreads under mach /])
2031 THREADOBJ="Python/thread.o"],[
2032 AC_MSG_CHECKING(for --with-pth)
2034 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
2035 [AC_MSG_RESULT($withval)
2036 AC_DEFINE([WITH_THREAD])
2037 AC_DEFINE([HAVE_PTH], 1,
2038 [Define if you have GNU PTH threads.])
2040 THREADOBJ="Python/thread.o"],
2043 # Just looking for pthread_create in libpthread is not enough:
2044 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
2045 # So we really have to include pthread.h, and then link.
2047 LIBS="$LIBS -lpthread"
2048 AC_MSG_CHECKING([for pthread_create in -lpthread])
2049 AC_TRY_LINK([#include <pthread.h>
2051 void * start_routine (void *arg) { exit (0); }], [
2052 pthread_create (NULL, NULL, start_routine, NULL)], [
2054 AC_DEFINE(WITH_THREAD)
2056 THREADOBJ="Python/thread.o"],[
2058 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
2060 THREADOBJ="Python/thread.o"],[
2061 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
2062 AC_DEFINE(ATHEOS_THREADS, 1,
2063 [Define this if you have AtheOS threads.])
2064 THREADOBJ="Python/thread.o"],[
2065 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
2066 AC_DEFINE(BEOS_THREADS, 1,
2067 [Define this if you have BeOS threads.])
2068 THREADOBJ="Python/thread.o"],[
2069 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
2071 LIBS="$LIBS -lpthreads"
2072 THREADOBJ="Python/thread.o"], [
2073 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
2076 THREADOBJ="Python/thread.o"], [
2077 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
2079 LIBS="$LIBS -lpthread"
2080 THREADOBJ="Python/thread.o"], [
2081 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
2084 THREADOBJ="Python/thread.o"],[
2085 USE_THREAD_MODULE="#"])
2086 ])])])])])])])])])])
2088 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
2090 THREADOBJ="Python/thread.o"
2091 USE_THREAD_MODULE=""])
2093 if test "$posix_threads" != "yes"; then
2094 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
2095 LIBS="$LIBS -lthread"
2096 THREADOBJ="Python/thread.o"
2097 USE_THREAD_MODULE=""])
2100 if test "$USE_THREAD_MODULE" != "#"
2102 # If the above checks didn't disable threads, (at least) OSF1
2103 # needs this '-threads' argument during linking.
2104 case $ac_sys_system in
2105 OSF1) LDLAST=-threads;;
2110 if test "$posix_threads" = "yes"; then
2111 if test "$unistd_defines_pthreads" = "no"; then
2112 AC_DEFINE(_POSIX_THREADS, 1,
2113 [Define if you have POSIX threads,
2114 and your system does not define that.])
2117 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
2118 case $ac_sys_system/$ac_sys_release in
2119 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
2120 Defined for Solaris 2.6 bug in pthread header.)
2122 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2123 Define if the Posix semaphores do not work on your system)
2125 AIX/5) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2126 Define if the Posix semaphores do not work on your system)
2130 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
2131 AC_CACHE_VAL(ac_cv_pthread_system_supported,
2132 [AC_TRY_RUN([#include <pthread.h>
2133 void *foo(void *parm) {
2137 pthread_attr_t attr;
2139 if (pthread_attr_init(&attr)) exit(-1);
2140 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
2141 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
2144 ac_cv_pthread_system_supported=yes,
2145 ac_cv_pthread_system_supported=no,
2146 ac_cv_pthread_system_supported=no)
2148 AC_MSG_RESULT($ac_cv_pthread_system_supported)
2149 if test "$ac_cv_pthread_system_supported" = "yes"; then
2150 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2152 AC_CHECK_FUNCS(pthread_sigmask,
2153 [case $ac_sys_system in
2155 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2156 [Define if pthread_sigmask() does not work on your system.])
2162 # Check for enable-ipv6
2163 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2164 AC_MSG_CHECKING([if --enable-ipv6 is specified])
2166 [ --enable-ipv6 Enable ipv6 (with ipv4) support
2167 --disable-ipv6 Disable ipv6 support],
2168 [ case "$enableval" in
2173 *) AC_MSG_RESULT(yes)
2174 AC_DEFINE(ENABLE_IPV6)
2180 dnl the check does not work on cross compilation case...
2181 AC_TRY_RUN([ /* AF_INET6 available check */
2182 #include <sys/types.h>
2183 #include <sys/socket.h>
2186 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2200 if test "$ipv6" = "yes"; then
2201 AC_MSG_CHECKING(if RFC2553 API is available)
2202 AC_TRY_COMPILE([#include <sys/types.h>
2203 #include <netinet/in.h>],
2204 [struct sockaddr_in6 x;
2208 AC_MSG_RESULT(no, IPv6 disabled)
2212 if test "$ipv6" = "yes"; then
2213 AC_DEFINE(ENABLE_IPV6)
2221 if test "$ipv6" = "yes"; then
2222 AC_MSG_CHECKING([ipv6 stack type])
2223 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2227 dnl http://www.kame.net/
2229 #include <netinet/in.h>
2230 #ifdef IPV6_INRIA_VERSION
2236 dnl http://www.kame.net/
2238 #include <netinet/in.h>
2244 ipv6libdir=/usr/local/v6/lib
2248 dnl http://www.v6.linux.or.jp/
2250 #include <features.h>
2251 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2258 dnl http://www.v6.linux.or.jp/
2259 if test -d /usr/inet6; then
2262 ipv6libdir=/usr/inet6/lib
2263 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2267 if test -f /etc/netconfig; then
2268 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2276 #include <sys/param.h>
2277 #ifdef _TOSHIBA_INET6
2282 ipv6libdir=/usr/local/v6/lib])
2286 #include </usr/local/v6/include/sys/v6config.h>
2292 ipv6libdir=/usr/local/v6/lib;
2293 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2297 #include <sys/param.h>
2298 #ifdef _ZETA_MINAMI_INET6
2303 ipv6libdir=/usr/local/v6/lib])
2306 if test "$ipv6type" != "unknown"; then
2310 AC_MSG_RESULT($ipv6type)
2313 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2314 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2315 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2316 echo "using lib$ipv6lib"
2318 if test $ipv6trylibc = "yes"; then
2321 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2322 echo "You need to fetch lib$ipv6lib.a from appropriate"
2323 echo 'ipv6 kit and compile beforehand.'
2329 AC_MSG_CHECKING(for OSX 10.5 SDK or later)
2330 AC_TRY_COMPILE([#include <Carbon/Carbon.h>], FSIORefNum fRef = 0,
2331 AC_DEFINE(HAVE_OSX105_SDK, 1, Define if compiling using MacOS X 10.5 SDK or later.)
2336 # Check for --with-doc-strings
2337 AC_MSG_CHECKING(for --with-doc-strings)
2338 AC_ARG_WITH(doc-strings,
2339 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2341 if test -z "$with_doc_strings"
2342 then with_doc_strings="yes"
2344 if test "$with_doc_strings" != "no"
2346 AC_DEFINE(WITH_DOC_STRINGS, 1,
2347 [Define if you want documentation strings in extension modules])
2349 AC_MSG_RESULT($with_doc_strings)
2351 # Check for Python-specific malloc support
2352 AC_MSG_CHECKING(for --with-tsc)
2354 [ --with(out)-tsc enable/disable timestamp counter profile], [
2355 if test "$withval" != no
2357 AC_DEFINE(WITH_TSC, 1,
2358 [Define to profile with the Pentium timestamp counter])
2360 else AC_MSG_RESULT(no)
2362 [AC_MSG_RESULT(no)])
2364 # Check for Python-specific malloc support
2365 AC_MSG_CHECKING(for --with-pymalloc)
2366 AC_ARG_WITH(pymalloc,
2367 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2369 if test -z "$with_pymalloc"
2370 then with_pymalloc="yes"
2372 if test "$with_pymalloc" != "no"
2374 AC_DEFINE(WITH_PYMALLOC, 1,
2375 [Define if you want to compile in Python-specific mallocs])
2377 AC_MSG_RESULT($with_pymalloc)
2379 # Check for --with-wctype-functions
2380 AC_MSG_CHECKING(for --with-wctype-functions)
2381 AC_ARG_WITH(wctype-functions,
2382 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2384 if test "$withval" != no
2386 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2387 [Define if you want wctype.h functions to be used instead of the
2388 one supplied by Python itself. (see Include/unicodectype.h).])
2390 else AC_MSG_RESULT(no)
2392 [AC_MSG_RESULT(no)])
2394 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2398 # the dlopen() function means we might want to use dynload_shlib.o. some
2399 # platforms, such as AIX, have dlopen(), but don't want to use it.
2400 AC_CHECK_FUNCS(dlopen)
2402 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2403 # loading of modules.
2404 AC_SUBST(DYNLOADFILE)
2405 AC_MSG_CHECKING(DYNLOADFILE)
2406 if test -z "$DYNLOADFILE"
2408 case $ac_sys_system/$ac_sys_release in
2409 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2410 if test "$ac_cv_func_dlopen" = yes
2411 then DYNLOADFILE="dynload_shlib.o"
2412 else DYNLOADFILE="dynload_aix.o"
2415 BeOS*) DYNLOADFILE="dynload_beos.o";;
2416 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2417 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2418 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2419 atheos*) DYNLOADFILE="dynload_atheos.o";;
2421 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2422 # out any dynamic loading
2423 if test "$ac_cv_func_dlopen" = yes
2424 then DYNLOADFILE="dynload_shlib.o"
2425 else DYNLOADFILE="dynload_stub.o"
2430 AC_MSG_RESULT($DYNLOADFILE)
2431 if test "$DYNLOADFILE" != "dynload_stub.o"
2433 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2434 [Defined when any dynamic module loading is enabled.])
2437 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2439 AC_SUBST(MACHDEP_OBJS)
2440 AC_MSG_CHECKING(MACHDEP_OBJS)
2441 if test -z "$MACHDEP_OBJS"
2443 MACHDEP_OBJS=$extra_machdep_objs
2445 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2447 AC_MSG_RESULT(MACHDEP_OBJS)
2449 # checks for library functions
2450 AC_CHECK_FUNCS(alarm setitimer getitimer bind_textdomain_codeset chown \
2451 clock confstr ctermid execv fchmod fchown fork fpathconf ftime ftruncate \
2452 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2453 getpriority getpwent getspnam getspent getsid getwd \
2454 kill killpg lchmod lchown lstat mkfifo mknod mktime \
2455 mremap nice pathconf pause plock poll pthread_init \
2456 putenv readlink realpath \
2457 select setegid seteuid setgid \
2458 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2459 sigaction siginterrupt sigrelse strftime \
2460 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2461 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2463 # For some functions, having a definition is not sufficient, since
2464 # we want to take their address.
2465 AC_MSG_CHECKING(for chroot)
2466 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2467 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2471 AC_MSG_CHECKING(for link)
2472 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2473 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2477 AC_MSG_CHECKING(for symlink)
2478 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2479 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2483 AC_MSG_CHECKING(for fchdir)
2484 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2485 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2489 AC_MSG_CHECKING(for fsync)
2490 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2491 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2495 AC_MSG_CHECKING(for fdatasync)
2496 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2497 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2501 AC_MSG_CHECKING(for epoll)
2502 AC_TRY_COMPILE([#include <sys/epoll.h>], void *x=epoll_create,
2503 AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
2507 AC_MSG_CHECKING(for kqueue)
2509 #include <sys/types.h>
2510 #include <sys/event.h>
2512 AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
2516 # On some systems (eg. FreeBSD 5), we would find a definition of the
2517 # functions ctermid_r, setgroups in the library, but no prototype
2518 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2519 # address to avoid compiler warnings and potential miscompilations
2520 # because of the missing prototypes.
2522 AC_MSG_CHECKING(for ctermid_r)
2524 #include "confdefs.h"
2526 ], void* p = ctermid_r,
2527 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2532 AC_MSG_CHECKING(for flock)
2534 #include "confdefs.h"
2535 #include <sys/file.h>
2537 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2542 AC_MSG_CHECKING(for getpagesize)
2544 #include "confdefs.h"
2546 ], void* p = getpagesize,
2547 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2553 AC_CHECK_PROGS(TRUE, true, /bin/true)
2555 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2556 dnl On others, they are in the C library, so we to take no action
2557 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2558 AC_CHECK_LIB(resolv, inet_aton)
2561 # On Tru64, chflags seems to be present, but calling it will
2563 AC_MSG_CHECKING(for chflags)
2565 #include <sys/stat.h>
2567 int main(int argc, char*argv[])
2569 if(chflags(argv[0], 0) != 0)
2573 ],AC_DEFINE(HAVE_CHFLAGS, 1, Define to 1 if you have the `chflags' function.)
2578 AC_MSG_CHECKING(for lchflags)
2580 #include <sys/stat.h>
2582 int main(int argc, char*argv[])
2584 if(lchflags(argv[0], 0) != 0)
2588 ],AC_DEFINE(HAVE_LCHFLAGS, 1, Define to 1 if you have the `lchflags' function.)
2593 dnl Check if system zlib has *Copy() functions
2595 dnl On MacOSX the linker will search for dylibs on the entire linker path
2596 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2597 dnl to revert to a more traditional unix behaviour and make it possible to
2598 dnl override the system libz with a local static library of libz. Temporarily
2599 dnl add that flag to our CFLAGS as well to ensure that we check the version
2600 dnl of libz that will be used by setup.py.
2601 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2602 dnl environment as setup.py (and leaving it out can cause configure to use the
2603 dnl wrong version of the library)
2604 case $ac_sys_system/$ac_sys_release in
2606 _CUR_CFLAGS="${CFLAGS}"
2607 _CUR_LDFLAGS="${LDFLAGS}"
2608 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2609 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2613 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2615 case $ac_sys_system/$ac_sys_release in
2617 CFLAGS="${_CUR_CFLAGS}"
2618 LDFLAGS="${_CUR_LDFLAGS}"
2622 AC_MSG_CHECKING(for hstrerror)
2624 #include "confdefs.h"
2626 ], void* p = hstrerror; hstrerror(0),
2627 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2632 AC_MSG_CHECKING(for inet_aton)
2634 #include "confdefs.h"
2635 #include <sys/types.h>
2636 #include <sys/socket.h>
2637 #include <netinet/in.h>
2638 #include <arpa/inet.h>
2639 ], void* p = inet_aton;inet_aton(0,0),
2640 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2645 AC_MSG_CHECKING(for inet_pton)
2647 #include "confdefs.h"
2648 #include <sys/types.h>
2649 #include <sys/socket.h>
2650 #include <netinet/in.h>
2651 #include <arpa/inet.h>
2652 ], void* p = inet_pton,
2653 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2658 # On some systems, setgroups is in unistd.h, on others, in grp.h
2659 AC_MSG_CHECKING(for setgroups)
2661 #include "confdefs.h"
2667 void* p = setgroups,
2668 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2673 # check for openpty and forkpty
2675 AC_CHECK_FUNCS(openpty,,
2676 AC_CHECK_LIB(util,openpty,
2677 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2678 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2681 AC_CHECK_FUNCS(forkpty,,
2682 AC_CHECK_LIB(util,forkpty,
2683 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2684 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2689 AC_CHECK_FUNCS(memmove)
2691 # check for long file support functions
2692 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2694 AC_REPLACE_FUNCS(dup2 getcwd strdup)
2695 AC_CHECK_FUNCS(getpgrp,
2696 AC_TRY_COMPILE([#include <unistd.h>],
2698 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2699 [Define if getpgrp() must be called as getpgrp(0).])
2702 AC_CHECK_FUNCS(setpgrp,
2703 AC_TRY_COMPILE([#include <unistd.h>],
2705 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2706 [Define if setpgrp() must be called as setpgrp(0, 0).])
2709 AC_CHECK_FUNCS(gettimeofday,
2710 AC_TRY_COMPILE([#include <sys/time.h>],
2711 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2712 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2713 [Define if gettimeofday() does not have second (timezone) argument
2714 This is the case on Motorola V4 (R40V4.2)])
2718 AC_MSG_CHECKING(for major, minor, and makedev)
2720 #if defined(MAJOR_IN_MKDEV)
2721 #include <sys/mkdev.h>
2722 #elif defined(MAJOR_IN_SYSMACROS)
2723 #include <sys/sysmacros.h>
2725 #include <sys/types.h>
2728 makedev(major(0),minor(0));
2730 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2731 [Define to 1 if you have the device macros.])
2737 # On OSF/1 V5.1, getaddrinfo is available, but a define
2738 # for [no]getaddrinfo in netdb.h.
2739 AC_MSG_CHECKING(for getaddrinfo)
2741 #include <sys/types.h>
2742 #include <sys/socket.h>
2746 getaddrinfo(NULL, NULL, NULL, NULL);
2749 AC_MSG_CHECKING(getaddrinfo bug)
2751 #include <sys/types.h>
2754 #include <sys/socket.h>
2755 #include <netinet/in.h>
2759 int passive, gaierr, inet4 = 0, inet6 = 0;
2760 struct addrinfo hints, *ai, *aitop;
2761 char straddr[INET6_ADDRSTRLEN], strport[16];
2763 for (passive = 0; passive <= 1; passive++) {
2764 memset(&hints, 0, sizeof(hints));
2765 hints.ai_family = AF_UNSPEC;
2766 hints.ai_flags = passive ? AI_PASSIVE : 0;
2767 hints.ai_socktype = SOCK_STREAM;
2768 hints.ai_protocol = IPPROTO_TCP;
2769 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2770 (void)gai_strerror(gaierr);
2773 for (ai = aitop; ai; ai = ai->ai_next) {
2774 if (ai->ai_addr == NULL ||
2775 ai->ai_addrlen == 0 ||
2776 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2777 straddr, sizeof(straddr), strport, sizeof(strport),
2778 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2781 switch (ai->ai_family) {
2783 if (strcmp(strport, "54321") != 0) {
2787 if (strcmp(straddr, "0.0.0.0") != 0) {
2791 if (strcmp(straddr, "127.0.0.1") != 0) {
2798 if (strcmp(strport, "54321") != 0) {
2802 if (strcmp(straddr, "::") != 0) {
2806 if (strcmp(straddr, "::1") != 0) {
2816 /* another family support? */
2822 if (!(inet4 == 0 || inet4 == 2))
2824 if (!(inet6 == 0 || inet6 == 2))
2828 freeaddrinfo(aitop);
2833 freeaddrinfo(aitop);
2838 buggygetaddrinfo=no,
2839 AC_MSG_RESULT(buggy)
2840 buggygetaddrinfo=yes,
2841 AC_MSG_RESULT(buggy)
2842 buggygetaddrinfo=yes)], [
2844 buggygetaddrinfo=yes
2847 if test "$buggygetaddrinfo" = "yes"; then
2848 if test "$ipv6" = "yes"; then
2849 echo 'Fatal: You must get working getaddrinfo() function.'
2850 echo ' or you can specify "--disable-ipv6"'.
2854 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2856 AC_CHECK_FUNCS(getnameinfo)
2858 # checks for structures
2862 AC_CHECK_MEMBERS([struct stat.st_rdev])
2863 AC_CHECK_MEMBERS([struct stat.st_blksize])
2864 AC_CHECK_MEMBERS([struct stat.st_flags])
2865 AC_CHECK_MEMBERS([struct stat.st_gen])
2866 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2869 AC_MSG_CHECKING(for time.h that defines altzone)
2870 AC_CACHE_VAL(ac_cv_header_time_altzone,
2871 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2872 ac_cv_header_time_altzone=yes,
2873 ac_cv_header_time_altzone=no)])
2874 AC_MSG_RESULT($ac_cv_header_time_altzone)
2875 if test $ac_cv_header_time_altzone = yes; then
2876 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2880 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2882 #include <sys/types.h>
2883 #include <sys/select.h>
2884 #include <sys/time.h>
2886 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2887 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2888 (which you can't on SCO ODT 3.0).])
2891 AC_MSG_RESULT($was_it_defined)
2893 AC_MSG_CHECKING(for addrinfo)
2894 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2896 # include <netdb.h>],
2897 [struct addrinfo a],
2898 ac_cv_struct_addrinfo=yes,
2899 ac_cv_struct_addrinfo=no))
2900 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2901 if test $ac_cv_struct_addrinfo = yes; then
2902 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2905 AC_MSG_CHECKING(for sockaddr_storage)
2906 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2908 # include <sys/types.h>
2909 # include <sys/socket.h>],
2910 [struct sockaddr_storage s],
2911 ac_cv_struct_sockaddr_storage=yes,
2912 ac_cv_struct_sockaddr_storage=no))
2913 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2914 if test $ac_cv_struct_sockaddr_storage = yes; then
2915 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2918 # checks for compiler characteristics
2924 AC_MSG_CHECKING(for working volatile)
2925 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2926 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2928 AC_MSG_RESULT($works)
2931 AC_MSG_CHECKING(for working signed char)
2932 AC_TRY_COMPILE([], [signed char c;], works=yes,
2933 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2935 AC_MSG_RESULT($works)
2938 AC_MSG_CHECKING(for prototypes)
2939 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2940 AC_DEFINE(HAVE_PROTOTYPES, 1,
2941 [Define if your compiler supports function prototype])
2944 AC_MSG_RESULT($have_prototypes)
2947 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2950 int foo(int x, ...) {
2958 ], [return foo(10, "", 3.14);], [
2959 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2960 [Define if your compiler supports variable length function prototypes
2961 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2964 AC_MSG_RESULT($works)
2966 # check for socketpair
2967 AC_MSG_CHECKING(for socketpair)
2969 #include <sys/types.h>
2970 #include <sys/socket.h>
2971 ], void *x=socketpair,
2972 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2977 # check if sockaddr has sa_len member
2978 AC_MSG_CHECKING(if sockaddr has sa_len member)
2979 AC_TRY_COMPILE([#include <sys/types.h>
2980 #include <sys/socket.h>],
2984 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2988 AC_MSG_CHECKING(whether va_list is an array)
2990 #ifdef HAVE_STDARG_PROTOTYPES
2993 #include <varargs.h>
2995 ], [va_list list1, list2; list1 = list2;], , [
2996 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2997 va_list_is_array=yes
2999 AC_MSG_RESULT($va_list_is_array)
3001 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
3002 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
3003 [Define this if you have some version of gethostbyname_r()])
3005 AC_CHECK_FUNC(gethostbyname_r, [
3006 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3007 AC_MSG_CHECKING([gethostbyname_r with 6 args])
3009 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
3014 struct hostent *he, *res;
3019 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
3021 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3022 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
3023 [Define this if you have the 6-arg version of gethostbyname_r().])
3027 AC_MSG_CHECKING([gethostbyname_r with 5 args])
3037 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
3039 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3040 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
3041 [Define this if you have the 5-arg version of gethostbyname_r().])
3045 AC_MSG_CHECKING([gethostbyname_r with 3 args])
3051 struct hostent_data data;
3053 (void) gethostbyname_r(name, he, &data);
3055 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3056 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
3057 [Define this if you have the 3-arg version of gethostbyname_r().])
3066 AC_CHECK_FUNCS(gethostbyname)
3068 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
3069 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
3070 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
3071 AC_SUBST(HAVE_GETHOSTBYNAME_R)
3072 AC_SUBST(HAVE_GETHOSTBYNAME)
3074 # checks for system services
3077 # Linux requires this for correct f.p. operations
3078 AC_CHECK_FUNC(__fpu_control,
3080 [AC_CHECK_LIB(ieee, __fpu_control)
3083 # Check for --with-fpectl
3084 AC_MSG_CHECKING(for --with-fpectl)
3086 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
3088 if test "$withval" != no
3090 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
3091 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
3093 else AC_MSG_RESULT(no)
3095 [AC_MSG_RESULT(no)])
3097 # check for --with-libm=...
3099 case $ac_sys_system in
3104 AC_MSG_CHECKING(for --with-libm=STRING)
3106 AC_HELP_STRING(--with-libm=STRING, math library),
3108 if test "$withval" = no
3110 AC_MSG_RESULT(force LIBM empty)
3111 elif test "$withval" != yes
3113 AC_MSG_RESULT(set LIBM="$withval")
3114 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
3116 [AC_MSG_RESULT(default LIBM="$LIBM")])
3118 # check for --with-libc=...
3120 AC_MSG_CHECKING(for --with-libc=STRING)
3122 AC_HELP_STRING(--with-libc=STRING, C library),
3124 if test "$withval" = no
3126 AC_MSG_RESULT(force LIBC empty)
3127 elif test "$withval" != yes
3129 AC_MSG_RESULT(set LIBC="$withval")
3130 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
3132 [AC_MSG_RESULT(default LIBC="$LIBC")])
3134 # ************************************
3135 # * Check for mathematical functions *
3136 # ************************************
3141 # On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
3142 # -0. on some architectures.
3143 AC_MSG_CHECKING(whether tanh preserves the sign of zero)
3144 AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
3149 /* return 0 if either negative zeros don't exist
3150 on this platform or if negative zeros exist
3151 and tanh(-0.) == -0. */
3152 if (atan2(0., -1.) == atan2(-0., -1.) ||
3153 atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
3157 ac_cv_tanh_preserves_zero_sign=yes,
3158 ac_cv_tanh_preserves_zero_sign=no,
3159 ac_cv_tanh_preserves_zero_sign=no)])
3160 AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
3161 if test "$ac_cv_tanh_preserves_zero_sign" = yes
3163 AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
3164 [Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
3167 AC_REPLACE_FUNCS(hypot)
3169 AC_CHECK_FUNCS(acosh asinh atanh copysign expm1 finite isinf isnan log1p)
3174 AC_CHECK_HEADER(wchar.h, [
3175 AC_DEFINE(HAVE_WCHAR_H, 1,
3176 [Define if the compiler provides a wchar.h header file.])
3182 # determine wchar_t size
3183 if test "$wchar_h" = yes
3185 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
3188 AC_MSG_CHECKING(for UCS-4 tcl)
3192 #if TCL_UTF_MAX != 6
3193 # error "NOT UCS4_TCL"
3195 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
3198 AC_MSG_RESULT($have_ucs4_tcl)
3200 # check whether wchar_t is signed or not
3201 if test "$wchar_h" = yes
3203 # check whether wchar_t is signed or not
3204 AC_MSG_CHECKING(whether wchar_t is signed)
3205 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
3210 /* Success: exit code 0 */
3211 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
3214 ac_cv_wchar_t_signed=yes,
3215 ac_cv_wchar_t_signed=no,
3216 ac_cv_wchar_t_signed=yes)])
3217 AC_MSG_RESULT($ac_cv_wchar_t_signed)
3220 AC_MSG_CHECKING(what type to use for unicode)
3221 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
3222 AC_ARG_ENABLE(unicode,
3223 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
3225 [enable_unicode=yes])
3227 if test $enable_unicode = yes
3229 # Without any arguments, Py_UNICODE defaults to two-byte mode
3230 case "$have_ucs4_tcl" in
3231 yes) enable_unicode="ucs4"
3233 *) enable_unicode="ucs2"
3238 AH_TEMPLATE(Py_UNICODE_SIZE,
3239 [Define as the size of the unicode type.])
3240 case "$enable_unicode" in
3241 ucs2) unicode_size="2"
3242 AC_DEFINE(Py_UNICODE_SIZE,2)
3244 ucs4) unicode_size="4"
3245 AC_DEFINE(Py_UNICODE_SIZE,4)
3249 AH_TEMPLATE(PY_UNICODE_TYPE,
3250 [Define as the integral type used for Unicode representation.])
3252 AC_SUBST(UNICODE_OBJS)
3253 if test "$enable_unicode" = "no"
3256 AC_MSG_RESULT(not used)
3258 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
3259 AC_DEFINE(Py_USING_UNICODE, 1,
3260 [Define if you want to have a Unicode type.])
3262 # wchar_t is only usable if it maps to an unsigned type
3263 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3264 -a "$ac_cv_wchar_t_signed" = "no"
3266 PY_UNICODE_TYPE="wchar_t"
3267 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3268 [Define if you have a useable wchar_t type defined in wchar.h; useable
3269 means wchar_t must be an unsigned type with at least 16 bits. (see
3270 Include/unicodeobject.h).])
3271 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3272 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3274 PY_UNICODE_TYPE="unsigned short"
3275 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3276 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3278 PY_UNICODE_TYPE="unsigned long"
3279 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3281 PY_UNICODE_TYPE="no type found"
3283 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
3329 AC_CHECK_LIB(readline, readline, , ,$READLINE_LIBS)
3330 if test "$ac_cv_have_readline_readline" = no
3332 AC_CHECK_LIB(termcap, readline)
3335 # check for readline 2.1
3336 AC_CHECK_LIB(readline, rl_callback_handler_install,
3337 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3338 [Define if you have readline 2.1]), ,$READLINE_LIBS)
3340 # check for readline 2.2
3341 AC_TRY_CPP([#include <readline/readline.h>],
3342 have_readline=yes, have_readline=no)
3343 if test $have_readline = yes
3345 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3346 [readline/readline.h],
3347 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3348 [Define if you have readline 2.2]), )
3351 # check for readline 4.0
3352 AC_CHECK_LIB(readline, rl_pre_input_hook,
3353 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3354 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3357 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
3358 AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
3359 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3361 # check for readline 4.2
3362 AC_CHECK_LIB(readline, rl_completion_matches,
3363 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3364 [Define if you have readline 4.2]), ,$READLINE_LIBS)
3366 # also in readline 4.2
3367 AC_TRY_CPP([#include <readline/readline.h>],
3368 have_readline=yes, have_readline=no)
3369 if test $have_readline = yes
3371 AC_EGREP_HEADER([extern int rl_catch_signals;],
3372 [readline/readline.h],
3373 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3374 [Define if you can turn off readline's signal handling.]), )
3377 # End of readline checks: restore LIBS
3378 LIBS=$LIBS_no_readline
3380 AC_MSG_CHECKING(for broken nice())
3381 AC_CACHE_VAL(ac_cv_broken_nice, [
3386 if (val1 != -1 && val1 == nice(2))
3391 ac_cv_broken_nice=yes,
3392 ac_cv_broken_nice=no,
3393 ac_cv_broken_nice=no)])
3394 AC_MSG_RESULT($ac_cv_broken_nice)
3395 if test "$ac_cv_broken_nice" = yes
3397 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3398 [Define if nice() returns success/failure instead of the new priority.])
3401 AC_MSG_CHECKING(for broken poll())
3407 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3411 int poll_test = poll (&poll_struct, 1, 0);
3417 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3427 ac_cv_broken_poll=yes,
3428 ac_cv_broken_poll=no,
3429 ac_cv_broken_poll=no)
3430 AC_MSG_RESULT($ac_cv_broken_poll)
3431 if test "$ac_cv_broken_poll" = yes
3433 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3434 [Define if poll() sets errno on invalid file descriptors.])
3437 # Before we can test tzset, we need to check if struct tm has a tm_zone
3438 # (which is not required by ISO C or UNIX spec) and/or if we support
3442 # check tzset(3) exists and works like we expect it to
3443 AC_MSG_CHECKING(for working tzset())
3444 AC_CACHE_VAL(ac_cv_working_tzset, [
3451 extern char *tzname[];
3456 /* Note that we need to ensure that not only does tzset(3)
3457 do 'something' with localtime, but it works as documented
3458 in the library reference and as expected by the test suite.
3459 This includes making sure that tzname is set properly if
3460 tm->tm_zone does not exist since it is the alternative way
3461 of getting timezone info.
3463 Red Hat 6.2 doesn't understand the southern hemisphere
3464 after New Year's Day.
3467 time_t groundhogday = 1044144000; /* GMT-based */
3468 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3472 if (localtime(&groundhogday)->tm_hour != 0)
3475 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3476 if (strcmp(tzname[0], "UTC") ||
3477 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3481 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3483 if (localtime(&groundhogday)->tm_hour != 19)
3486 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3490 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3492 if (localtime(&groundhogday)->tm_hour != 11)
3495 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3499 #if HAVE_STRUCT_TM_TM_ZONE
3500 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3502 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3509 ac_cv_working_tzset=yes,
3510 ac_cv_working_tzset=no,
3511 ac_cv_working_tzset=no)])
3512 AC_MSG_RESULT($ac_cv_working_tzset)
3513 if test "$ac_cv_working_tzset" = yes
3515 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3516 [Define if tzset() actually switches the local timezone in a meaningful way.])
3519 # Look for subsecond timestamps in struct stat
3520 AC_MSG_CHECKING(for tv_nsec in struct stat)
3521 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3522 AC_TRY_COMPILE([#include <sys/stat.h>], [
3524 st.st_mtim.tv_nsec = 1;
3526 ac_cv_stat_tv_nsec=yes,
3527 ac_cv_stat_tv_nsec=no,
3528 ac_cv_stat_tv_nsec=no))
3529 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3530 if test "$ac_cv_stat_tv_nsec" = yes
3532 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3533 [Define if you have struct stat.st_mtim.tv_nsec])
3536 # Look for BSD style subsecond timestamps in struct stat
3537 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3538 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3539 AC_TRY_COMPILE([#include <sys/stat.h>], [
3541 st.st_mtimespec.tv_nsec = 1;
3543 ac_cv_stat_tv_nsec2=yes,
3544 ac_cv_stat_tv_nsec2=no,
3545 ac_cv_stat_tv_nsec2=no))
3546 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3547 if test "$ac_cv_stat_tv_nsec2" = yes
3549 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3550 [Define if you have struct stat.st_mtimensec])
3553 # On HP/UX 11.0, mvwdelch is a block with a return statement
3554 AC_MSG_CHECKING(whether mvwdelch is an expression)
3555 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3556 AC_TRY_COMPILE([#include <curses.h>], [
3558 rtn = mvwdelch(0,0,0);
3559 ], ac_cv_mvwdelch_is_expression=yes,
3560 ac_cv_mvwdelch_is_expression=no,
3561 ac_cv_mvwdelch_is_expression=yes))
3562 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3564 if test "$ac_cv_mvwdelch_is_expression" = yes
3566 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3567 [Define if mvwdelch in curses.h is an expression.])
3570 AC_MSG_CHECKING(whether WINDOW has _flags)
3571 AC_CACHE_VAL(ac_cv_window_has_flags,
3572 AC_TRY_COMPILE([#include <curses.h>], [
3575 ], ac_cv_window_has_flags=yes,
3576 ac_cv_window_has_flags=no,
3577 ac_cv_window_has_flags=no))
3578 AC_MSG_RESULT($ac_cv_window_has_flags)
3581 if test "$ac_cv_window_has_flags" = yes
3583 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3584 [Define if WINDOW in curses.h offers a field _flags.])
3587 AC_MSG_CHECKING(for is_term_resized)
3588 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3589 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3594 AC_MSG_CHECKING(for resize_term)
3595 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3596 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3601 AC_MSG_CHECKING(for resizeterm)
3602 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3603 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3608 AC_MSG_CHECKING(for /dev/ptmx)
3610 if test -r /dev/ptmx
3613 AC_DEFINE(HAVE_DEV_PTMX, 1,
3614 [Define if we have /dev/ptmx.])
3619 AC_MSG_CHECKING(for /dev/ptc)
3624 AC_DEFINE(HAVE_DEV_PTC, 1,
3625 [Define if we have /dev/ptc.])
3630 AC_MSG_CHECKING(for %zd printf() format support)
3631 AC_TRY_RUN([#include <stdio.h>
3635 #ifdef HAVE_SYS_TYPES_H
3636 #include <sys/types.h>
3640 typedef ssize_t Py_ssize_t;
3641 #elif SIZEOF_VOID_P == SIZEOF_LONG
3642 typedef long Py_ssize_t;
3644 typedef int Py_ssize_t;
3651 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3654 if (strcmp(buffer, "123"))
3657 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3660 if (strcmp(buffer, "-123"))
3666 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3669 AC_CHECK_TYPE(socklen_t,,
3670 AC_DEFINE(socklen_t,int,
3671 Define to `int' if <sys/socket.h> does not define.),[
3672 #ifdef HAVE_SYS_TYPES_H
3673 #include <sys/types.h>
3675 #ifdef HAVE_SYS_SOCKET_H
3676 #include <sys/socket.h>
3680 AC_SUBST(THREADHEADERS)
3682 for h in `(cd $srcdir;echo Python/thread_*.h)`
3684 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3688 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3689 AC_MSG_CHECKING(for build directories)
3690 for dir in $SRCDIRS; do
3691 if test ! -d $dir; then
3697 # generate output files
3698 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3701 echo "creating Modules/Setup"
3702 if test ! -f Modules/Setup
3704 cp $srcdir/Modules/Setup.dist Modules/Setup
3707 echo "creating Modules/Setup.local"
3708 if test ! -f Modules/Setup.local
3710 echo "# Edit this file for local setup changes" >Modules/Setup.local
3713 echo "creating Makefile"
3714 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3715 -s Modules Modules/Setup.config \
3716 Modules/Setup.local Modules/Setup
3718 case $ac_sys_system in
3722 Support for BeOS is deprecated as of Python 2.6.
3723 See PEP 11 for the gory details.