1 dnl Process this file with autoconf 2.0 or later to make a configure script.
3 # Set VERSION so we only need to edit in one place (i.e., here)
4 m4_define(PYTHON_VERSION, 2.5)
6 AC_REVISION($Revision$)
8 AC_INIT(python, PYTHON_VERSION, http://www.python.org/python-bugs)
9 AC_CONFIG_SRCDIR([Include/object.h])
10 AC_CONFIG_HEADER(pyconfig.h)
12 dnl This is for stuff that absolutely must end up in pyconfig.h.
13 dnl Please use pyport.h instead, if possible.
19 /* Define the macros needed if on a UnixWare 7.x system. */
20 #if defined(__USLC__) && defined(__SCO_VERSION__)
21 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
24 #endif /*Py_PYCONFIG_H*/
27 # We don't use PACKAGE_ variables, and they cause conflicts
28 # with other autoconf-based packages that include Python.h
29 grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
31 mv confdefs.h.new confdefs.h
34 VERSION=PYTHON_VERSION
39 # The later defininition of _XOPEN_SOURCE disables certain features
40 # on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
41 AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])
43 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
44 # certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
46 AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])
48 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
49 # certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
51 AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])
53 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
54 # u_int on Irix 5.3. Defining _BSD_TYPES brings it back.
55 AC_DEFINE(_BSD_TYPES, 1, [Define on Irix to enable u_int])
57 define_xopen_source=yes
59 # Arguments passed to configure.
61 CONFIG_ARGS="$ac_configure_args"
63 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
64 AC_ARG_ENABLE(framework,
65 AC_HELP_STRING(--enable-framework@<:@=INSTALLDIR@:>@, Build (MacOSX|Darwin) framework),
69 enableval=/Library/Frameworks
74 PYTHONFRAMEWORKDIR=no-framework
75 PYTHONFRAMEWORKPREFIX=
76 PYTHONFRAMEWORKINSTALLDIR=
80 PYTHONFRAMEWORK=Python
81 PYTHONFRAMEWORKDIR=Python.framework
82 PYTHONFRAMEWORKPREFIX=$enableval
83 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
84 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
88 PYTHONFRAMEWORKDIR=no-framework
89 PYTHONFRAMEWORKPREFIX=
90 PYTHONFRAMEWORKINSTALLDIR=
93 AC_SUBST(PYTHONFRAMEWORK)
94 AC_SUBST(PYTHONFRAMEWORKDIR)
95 AC_SUBST(PYTHONFRAMEWORKPREFIX)
96 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
99 ## AC_HELP_STRING(--with-dyld,
100 ## Use (OpenStep|Rhapsody) dynamic linker))
102 # Set name for machine-dependent library files
104 AC_MSG_CHECKING(MACHDEP)
105 if test -z "$MACHDEP"
107 ac_sys_system=`uname -s`
108 if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64" \
109 -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
110 ac_sys_release=`uname -v`
112 ac_sys_release=`uname -r`
114 ac_md_system=`echo $ac_sys_system |
115 tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
116 ac_md_release=`echo $ac_sys_release |
117 tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
118 MACHDEP="$ac_md_system$ac_md_release"
121 cygwin*) MACHDEP="cygwin";;
122 darwin*) MACHDEP="darwin";;
123 atheos*) MACHDEP="atheos";;
124 irix646) MACHDEP="irix6";;
125 '') MACHDEP="unknown";;
129 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
130 # disable features if it is defined, without any means to access these
131 # features as extensions. For these systems, we skip the definition of
132 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
133 # some feature, make sure there is no alternative way to access this
134 # feature. Also, when using wildcards, make sure you have verified the
135 # need for not defining _XOPEN_SOURCE on all systems matching the
136 # wildcard, and that the wildcard does not include future systems
137 # (which may remove their limitations).
138 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
139 case $ac_sys_system/$ac_sys_release in
140 # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
141 # even though select is a POSIX function. Reported by J. Ribbens.
142 # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
143 OpenBSD/2.* | OpenBSD/3.@<:@012345678@:>@)
144 define_xopen_source=no;;
145 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
146 # of union __?sigval. Reported by Stuart Bishop.
148 define_xopen_source=no;;
149 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
150 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
151 # Reconfirmed for 7.1.4 by Martin v. Loewis.
152 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
153 define_xopen_source=no;;
154 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
155 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
157 define_xopen_source=no;;
158 # On FreeBSD 4.8 and MacOS X 10.2, a bug in ncurses.h means that
159 # it craps out if _XOPEN_EXTENDED_SOURCE is defined. Apparently,
160 # this is fixed in 10.3, which identifies itself as Darwin/7.*
161 # This should hopefully be fixed in FreeBSD 4.9
162 FreeBSD/4.8* | Darwin/6* )
163 define_xopen_source=no;;
164 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
165 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
166 # or has another value. By not (re)defining it, the defaults come in place.
168 define_xopen_source=no;;
170 if test `uname -r` -eq 1; then
171 define_xopen_source=no
174 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
175 # disables platform specific features beyond repair.
177 define_xopen_source=no
182 if test $define_xopen_source = yes
184 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
185 # defined precisely as g++ defines it
186 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
188 case $ac_sys_system/$ac_sys_release in
189 SunOS/5.8|SunOS/5.9|SunOS/5.10)
190 AC_DEFINE(_XOPEN_SOURCE, 500,
191 Define to the level of X/Open that your system supports)
194 AC_DEFINE(_XOPEN_SOURCE, 600,
195 Define to the level of X/Open that your system supports)
199 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
200 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
201 # several APIs are not declared. Since this is also needed in some
202 # cases for HP-UX, we define it globally.
203 # except for Solaris 10, where it must not be defined,
204 # as it implies XPG4.2
205 case $ac_sys_system/$ac_sys_release in
209 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
210 Define to activate Unix95-and-earlier features)
214 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
219 # SGI compilers allow the specification of the both the ABI and the
220 # ISA on the command line. Depending on the values of these switches,
221 # different and often incompatable code will be generated.
223 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
224 # thus supply support for various ABI/ISA combinations. The MACHDEP
225 # variable is also adjusted.
228 if test ! -z "$SGI_ABI"
231 LDFLAGS="$SGI_ABI $LDFLAGS"
232 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
234 AC_MSG_RESULT($MACHDEP)
236 # And add extra plat-mac for darwin
237 AC_SUBST(EXTRAPLATDIR)
238 AC_SUBST(EXTRAMACHDEPPATH)
239 AC_MSG_CHECKING(EXTRAPLATDIR)
240 if test -z "$EXTRAPLATDIR"
244 EXTRAPLATDIR="\$(PLATMACDIRS)"
245 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
253 AC_MSG_RESULT($EXTRAPLATDIR)
255 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
256 # it may influence the way we can build extensions, so distutils
258 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
259 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
261 # checks for alternative programs
263 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
264 # for debug/optimization stuff. BASECFLAGS is for flags that are required
265 # just to get things to compile and link. Users are free to override OPT
266 # when running configure or make. The build should not break if they do.
267 # BASECFLAGS should generally not be messed with, however.
269 # XXX shouldn't some/most/all of this code be merged with the stuff later
270 # on that fiddles with OPT and BASECFLAGS?
271 AC_MSG_CHECKING(for --without-gcc)
273 AC_HELP_STRING(--without-gcc,never use gcc),
281 without_gcc=$withval;;
283 case $ac_sys_system in
291 BASECFLAGS="$BASECFLAGS -export pragma"
293 LDFLAGS="$LDFLAGS -nodup"
301 AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
304 AR="\$(srcdir)/Modules/ar_beos"
312 AC_MSG_RESULT($without_gcc)
317 AC_MSG_CHECKING(for --with-cxx=<compiler>)
319 AC_HELP_STRING(--with-cxx=<compiler>, enable C++ support),
332 AC_MSG_RESULT($with_cxx)
334 if test "$with_cxx" = "yes"
336 AC_MSG_ERROR([must supply a compiler when using --with-cxx])
339 dnl The following fragment works similar to AC_PROG_CXX.
340 dnl It does not fail if CXX is not found, and it is not executed if
341 dnl --without-cxx was given.
342 dnl Finally, it does not test whether CXX is g++.
344 dnl Autoconf 2.5x does not have AC_PROG_CXX_WORKS anymore
345 ifdef([AC_PROG_CXX_WORKS],[],
346 [AC_DEFUN([AC_PROG_CXX_WORKS],
347 [AC_LANG_PUSH(C++)dnl
353 if test "$check_cxx" = "yes"
355 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
356 if test "$CXX" = "notfound"
364 # If the user switches compilers, we can't believe the cache
365 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
367 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
368 (it is also a good idea to do 'make clean' before compiling)])
373 # checks for UNIX variants that set C preprocessor variables
376 # Check for unsupported systems
377 case $ac_sys_system/$ac_sys_release in
379 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
380 echo See README for details.
385 AC_MSG_CHECKING(for --with-suffix)
387 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
394 AC_MSG_RESULT($EXEEXT)
396 # Test whether we're running on a non-case-sensitive system, in which
397 # case we give a warning if no ext is given
398 AC_SUBST(BUILDEXEEXT)
399 AC_MSG_CHECKING(for case-insensitive build directory)
400 if test ! -d CaseSensitiveTestDir; then
401 mkdir CaseSensitiveTestDir
404 if test -d casesensitivetestdir
412 rmdir CaseSensitiveTestDir
417 gcc) CC="$CC -D_HAVE_BSDI";;
421 case $ac_sys_system in
424 cc|*/cc) CC="$CC -Ae";;
428 cc) CC="$CC -Wl,-Bexport";;
431 # Some functions have a prototype only with that define, e.g. confstr
432 AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
438 AC_MSG_CHECKING(LIBRARY)
439 if test -z "$LIBRARY"
441 LIBRARY='libpython$(VERSION).a'
443 AC_MSG_RESULT($LIBRARY)
445 # LDLIBRARY is the name of the library to link against (as opposed to the
446 # name of the library into which to insert object files). BLDLIBRARY is also
447 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
448 # is blank as the main program is not linked directly against LDLIBRARY.
449 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
450 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
451 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
452 # DLLLIBRARY is the shared (i.e., DLL) library.
454 # RUNSHARED is used to run shared python without installed libraries
456 # INSTSONAME is the name of the shared library that will be use to install
457 # on the system - some systems like version suffix, others don't
461 AC_SUBST(LDLIBRARYDIR)
465 BLDLIBRARY='$(LDLIBRARY)'
466 INSTSONAME='$(LDLIBRARY)'
471 # LINKCC is the command that links the python executable -- default is $(CC).
472 # If CXX is set, and if it is needed to link a main function that was
473 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
474 # python might then depend on the C++ runtime
475 # This is altered for AIX in order to build the export list before
478 AC_MSG_CHECKING(LINKCC)
481 if test -z "$CXX"; then
482 LINKCC="\$(PURIFY) \$(CC)"
484 echo 'extern "C" void foo();int main(){foo();}' > conftest_a.cc
485 $CXX -c conftest_a.cc # 2>&5
486 echo 'void foo(){}' > conftest_b.$ac_ext
487 $CC -c conftest_b.$ac_ext # 2>&5
488 if $CC -o conftest$ac_exeext conftest_a.$ac_objext conftest_b.$ac_objext 2>&5 \
489 && test -s conftest$ac_exeext && ./conftest$ac_exeext
491 LINKCC="\$(PURIFY) \$(CC)"
493 LINKCC="\$(PURIFY) \$(CXX)"
497 case $ac_sys_system in
500 if test $ac_sys_release -ge 5 -o \
501 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
504 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
506 LINKCC="$LINKCC -L/usr/lib/ia64l64";;
509 AC_MSG_RESULT($LINKCC)
511 AC_MSG_CHECKING(for --enable-shared)
512 AC_ARG_ENABLE(shared,
513 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
515 if test -z "$enable_shared"
517 case $ac_sys_system in
519 enable_shared="yes";;
524 AC_MSG_RESULT($enable_shared)
526 AC_MSG_CHECKING(for --enable-profiling)
527 AC_ARG_ENABLE(profiling,
528 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
531 AC_TRY_RUN([int main() { return 0; }],
532 ac_enable_profiling="yes",
533 ac_enable_profiling="no",
534 ac_enable_profiling="no")
536 AC_MSG_RESULT($ac_enable_profiling)
538 case "$ac_enable_profiling" in
540 BASECFLAGS="-pg $BASECFLAGS"
541 LDFLAGS="-pg $LDFLAGS"
545 AC_MSG_CHECKING(LDLIBRARY)
547 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
548 # library that we build, but we do not want to link against it (we
549 # will find it with a -framework option). For this reason there is an
550 # extra variable BLDLIBRARY against which Python and the extension
551 # modules are linked, BLDLIBRARY. This is normally the same as
552 # LDLIBRARY, but empty for MacOSX framework builds.
553 if test "$enable_framework"
555 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
556 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
559 BLDLIBRARY='$(LDLIBRARY)'
562 # Other platforms follow
563 if test $enable_shared = "yes"; then
564 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
565 case $ac_sys_system in
567 LDLIBRARY='libpython$(VERSION).so'
570 LDLIBRARY='libpython$(VERSION).dll.a'
571 DLLLIBRARY='libpython$(VERSION).dll'
574 LDLIBRARY='libpython$(VERSION).so'
575 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
576 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
577 INSTSONAME="$LDLIBRARY".$SOVERSION
579 Linux*|GNU*|NetBSD*|FreeBSD*)
580 LDLIBRARY='libpython$(VERSION).so'
581 BLDLIBRARY='-L. -lpython$(VERSION)'
582 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
583 case $ac_sys_system in
585 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
588 INSTSONAME="$LDLIBRARY".$SOVERSION
591 LDLIBRARY='libpython$(VERSION).sl'
592 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
593 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
596 LDLIBRARY='libpython$(VERSION).so'
597 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
598 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
601 LDLIBRARY='libpython$(VERSION).so'
602 BLDLIBRARY='-L. -lpython$(VERSION)'
603 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
606 else # shared is disabled
607 case $ac_sys_system in
609 BLDLIBRARY='$(LIBRARY)'
610 LDLIBRARY='libpython$(VERSION).dll.a'
615 AC_MSG_RESULT($LDLIBRARY)
619 AC_CHECK_PROGS(AR, ar aal, ar)
622 AC_CHECK_PROG(SVNVERSION, svnversion, found)
623 if test $SVNVERSION = found
625 SVNVERSION="svnversion \$(srcdir)"
627 SVNVERSION="echo exported"
632 # install -d does not work on BSDI or HP-UX
633 if test -z "$INSTALL"
635 INSTALL="${srcdir}/install-sh -c"
640 # Not every filesystem supports hard links
642 if test -z "$LN" ; then
643 case $ac_sys_system in
645 CYGWIN*) LN="ln -s";;
646 atheos*) LN="ln -s";;
651 # Check for --with-pydebug
652 AC_MSG_CHECKING(for --with-pydebug)
654 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
656 if test "$withval" != no
658 AC_DEFINE(Py_DEBUG, 1,
659 [Define if you want to build an interpreter with many run-time checks.])
662 else AC_MSG_RESULT(no); Py_DEBUG='false'
666 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
667 # merged with this chunk of code?
669 # Optimizer/debugger flags
670 # ------------------------
671 # (The following bit of code is complicated enough - please keep things
672 # indented properly. Just pretend you're editing Python code. ;-)
674 # There are two parallel sets of case statements below, one that checks to
675 # see if OPT was set and one that does BASECFLAGS setting based upon
676 # compiler and platform. BASECFLAGS tweaks need to be made even if the
679 # tweak OPT based on compiler and platform, only if the user didn't set
680 # it on the command line
686 case $ac_cv_prog_cc_g in
688 if test "$Py_DEBUG" = 'true' ; then
689 # Optimization messes up debuggers, so turn it off for
691 OPT="-g -Wall -Wstrict-prototypes"
693 OPT="-g -O3 -Wall -Wstrict-prototypes"
697 OPT="-O3 -Wall -Wstrict-prototypes"
700 case $ac_sys_system in
701 SCO_SV*) OPT="$OPT -m486 -DSCO5"
711 # The current (beta) Monterey compiler dies with optimizations
712 # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
713 case $ac_sys_system in
722 # tweak BASECFLAGS based on compiler and platform
725 # Python violates C99 rules, by casting between incompatible
726 # pointer types. GCC may generate bad code as a result of that,
727 # so use -fno-strict-aliasing if supported.
728 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
730 CC="$CC -fno-strict-aliasing"
731 AC_TRY_RUN([int main() { return 0; }],
732 ac_cv_no_strict_aliasing_ok=yes,
733 ac_cv_no_strict_aliasing_ok=no,
734 ac_cv_no_strict_aliasing_ok=no)
736 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
737 if test $ac_cv_no_strict_aliasing_ok = yes
739 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
741 case $ac_sys_system in
743 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
745 # is there any other compiler on Darwin besides gcc?
747 BASECFLAGS="$BASECFLAGS -Wno-long-double -no-cpp-precomp -mno-fused-madd"
753 case $ac_sys_system in
755 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
758 BASECFLAGS="$BASECFLAGS -ieee -std"
761 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
767 if test "$Py_DEBUG" = 'true'; then
773 if test "$ac_arch_flags"
775 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
778 # disable check for icc since it seems to pass, but generates a warning
781 ac_cv_opt_olimit_ok=no
784 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
785 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
787 CC="$CC -OPT:Olimit=0"
788 AC_TRY_RUN([int main() { return 0; }],
789 ac_cv_opt_olimit_ok=yes,
790 ac_cv_opt_olimit_ok=no,
791 ac_cv_opt_olimit_ok=no)
793 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
794 if test $ac_cv_opt_olimit_ok = yes; then
795 case $ac_sys_system in
796 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
797 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
802 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
806 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
807 AC_CACHE_VAL(ac_cv_olimit_ok,
809 CC="$CC -Olimit 1500"
810 AC_TRY_RUN([int main() { return 0; }],
815 AC_MSG_RESULT($ac_cv_olimit_ok)
816 if test $ac_cv_olimit_ok = yes; then
817 BASECFLAGS="$BASECFLAGS -Olimit 1500"
821 # On some compilers, pthreads are available without further options
822 # (e.g. MacOS X). On some of these systems, the compiler will not
823 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
824 # So we have to see first whether pthreads are available without
825 # options before we can check whether -Kpthread improves anything.
826 AC_MSG_CHECKING(whether pthreads are available without options)
827 AC_CACHE_VAL(ac_cv_pthread_is_default,
831 void* routine(void* p){return NULL;}
835 if(pthread_create(&p,NULL,routine,NULL)!=0)
837 (void)pthread_detach(p);
842 ac_cv_pthread_is_default=yes
846 ac_cv_pthread_is_default=no,
847 ac_cv_pthread_is_default=no)
849 AC_MSG_RESULT($ac_cv_pthread_is_default)
852 if test $ac_cv_pthread_is_default = yes
856 # -Kpthread, if available, provides the right #defines
857 # and linker options to make pthread_create available
858 # Some compilers won't report that they do not support -Kpthread,
859 # so we need to run a program to see whether it really made the
860 # function available.
861 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
862 AC_CACHE_VAL(ac_cv_kpthread,
868 void* routine(void* p){return NULL;}
872 if(pthread_create(&p,NULL,routine,NULL)!=0)
874 (void)pthread_detach(p);
882 AC_MSG_RESULT($ac_cv_kpthread)
885 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
887 # -Kthread, if available, provides the right #defines
888 # and linker options to make pthread_create available
889 # Some compilers won't report that they do not support -Kthread,
890 # so we need to run a program to see whether it really made the
891 # function available.
892 AC_MSG_CHECKING(whether $CC accepts -Kthread)
893 AC_CACHE_VAL(ac_cv_kthread,
899 void* routine(void* p){return NULL;}
903 if(pthread_create(&p,NULL,routine,NULL)!=0)
905 (void)pthread_detach(p);
913 AC_MSG_RESULT($ac_cv_kthread)
916 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
918 # -pthread, if available, provides the right #defines
919 # and linker options to make pthread_create available
920 # Some compilers won't report that they do not support -pthread,
921 # so we need to run a program to see whether it really made the
922 # function available.
923 AC_MSG_CHECKING(whether $CC accepts -pthread)
924 AC_CACHE_VAL(ac_cv_thread,
930 void* routine(void* p){return NULL;}
934 if(pthread_create(&p,NULL,routine,NULL)!=0)
936 (void)pthread_detach(p);
944 AC_MSG_RESULT($ac_cv_pthread)
947 # If we have set a CC compiler flag for thread support then
948 # check if it works for CXX, too.
952 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
955 if test "$ac_cv_kpthread" = "yes"
959 elif test "$ac_cv_kthread" = "yes"
963 elif test "$ac_cv_pthread" = "yes"
969 if test $ac_cv_cxx_thread = yes
971 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
972 $CXX -c conftest.$ac_ext 2>&5
973 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
974 && test -s conftest$ac_exeext && ./conftest$ac_exeext
982 AC_MSG_RESULT($ac_cv_cxx_thread)
986 dnl # check for ANSI or K&R ("traditional") preprocessor
987 dnl AC_MSG_CHECKING(for C preprocessor type)
989 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
991 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
992 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
993 dnl AC_MSG_RESULT($cpp_type)
995 # checks for header files
997 AC_CHECK_HEADERS(asm/types.h curses.h dlfcn.h fcntl.h grp.h \
998 shadow.h langinfo.h libintl.h ncurses.h poll.h pthread.h \
999 stropts.h termios.h thread.h \
1001 sys/audioio.h sys/bsdtty.h sys/file.h sys/loadavg.h sys/lock.h sys/mkdev.h \
1003 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/time.h sys/times.h \
1004 sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1005 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1006 bluetooth/bluetooth.h)
1010 # On Solaris, term.h requires curses.h
1011 AC_CHECK_HEADERS(term.h,,,[
1012 #ifdef HAVE_CURSES_H
1017 # On Linux, netlink.h requires asm/types.h
1018 AC_CHECK_HEADERS(linux/netlink.h,,,[
1019 #ifdef HAVE_ASM_TYPES_H
1020 #include <asm/types.h>
1022 #ifdef HAVE_SYS_SOCKET_H
1023 #include <sys/socket.h>
1027 # checks for typedefs
1029 AC_MSG_CHECKING(for clock_t in time.h)
1030 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1031 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1033 AC_MSG_RESULT($was_it_defined)
1035 # Check whether using makedev requires defining _OSF_SOURCE
1036 AC_MSG_CHECKING(for makedev)
1037 AC_TRY_LINK([#include <sys/types.h> ],
1039 ac_cv_has_makedev=yes,
1040 ac_cv_has_makedev=no)
1041 if test "$ac_cv_has_makedev" = "no"; then
1042 # we didn't link, try if _OSF_SOURCE will allow us to link
1044 #define _OSF_SOURCE 1
1045 #include <sys/types.h>
1048 ac_cv_has_makedev=yes,
1049 ac_cv_has_makedev=no)
1050 if test "$ac_cv_has_makedev" = "yes"; then
1051 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1054 AC_MSG_RESULT($ac_cv_has_makedev)
1055 if test "$ac_cv_has_makedev" = "yes"; then
1056 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1059 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1060 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1061 # defined, but the compiler does not support pragma redefine_extname,
1062 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1063 # structures (such as rlimit64) without declaring them. As a
1064 # work-around, disable LFS on such configurations
1067 AC_MSG_CHECKING(Solaris LFS bug)
1069 #define _LARGEFILE_SOURCE 1
1070 #define _FILE_OFFSET_BITS 64
1071 #include <sys/resource.h>
1072 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1073 AC_MSG_RESULT($sol_lfs_bug)
1074 if test "$sol_lfs_bug" = "yes"; then
1078 if test "$use_lfs" = "yes"; then
1079 # Two defines needed to enable largefile support on various platforms
1080 # These may affect some typedefs
1081 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1082 [This must be defined on some systems to enable large file support.])
1083 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1084 [This must be set to 64 on some systems to enable large file support.])
1087 # Add some code to confdefs.h so that the test for off_t works on SCO
1088 cat >> confdefs.h <<\EOF
1094 # Type availability checks
1102 # Sizes of various common basic types
1103 # ANSI C requires sizeof(char) == 1, so no need to check it
1104 AC_CHECK_SIZEOF(int, 4)
1105 AC_CHECK_SIZEOF(long, 4)
1106 AC_CHECK_SIZEOF(void *, 4)
1107 AC_CHECK_SIZEOF(short, 2)
1108 AC_CHECK_SIZEOF(float, 4)
1109 AC_CHECK_SIZEOF(double, 8)
1110 AC_CHECK_SIZEOF(fpos_t, 4)
1112 AC_MSG_CHECKING(for long long support)
1114 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1115 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1118 AC_MSG_RESULT($have_long_long)
1119 if test "$have_long_long" = yes ; then
1120 AC_CHECK_SIZEOF(long long, 8)
1123 AC_MSG_CHECKING(for uintptr_t support)
1125 AC_TRY_COMPILE([], [uintptr_t x; x = (uintptr_t)0;], [
1126 AC_DEFINE(HAVE_UINTPTR_T, 1, [Define this if you have the type uintptr_t.])
1129 AC_MSG_RESULT($have_uintptr_t)
1130 if test "$have_uintptr_t" = yes ; then
1131 AC_CHECK_SIZEOF(uintptr_t, 4)
1134 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1135 AC_MSG_CHECKING(size of off_t)
1136 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1137 [AC_TRY_RUN([#include <stdio.h>
1138 #include <sys/types.h>
1141 FILE *f=fopen("conftestval", "w");
1143 fprintf(f, "%d\n", sizeof(off_t));
1146 ac_cv_sizeof_off_t=`cat conftestval`,
1147 ac_cv_sizeof_off_t=0,
1148 ac_cv_sizeof_off_t=4)
1150 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1151 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1152 [The number of bytes in an off_t.])
1154 AC_MSG_CHECKING(whether to enable large file support)
1155 if test "$have_long_long" = yes -a \
1156 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1157 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1158 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1159 [Defined to enable large file support when an off_t is bigger than a long
1160 and long long is available and at least as big as an off_t. You may need
1161 to add some flags for configuration and compilation to enable this mode.
1162 (For Solaris and Linux, the necessary defines are already defined.)])
1168 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1169 AC_MSG_CHECKING(size of time_t)
1170 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1171 [AC_TRY_RUN([#include <stdio.h>
1175 FILE *f=fopen("conftestval", "w");
1177 fprintf(f, "%d\n", sizeof(time_t));
1180 ac_cv_sizeof_time_t=`cat conftestval`,
1181 ac_cv_sizeof_time_t=0,
1182 ac_cv_sizeof_time_t=4)
1184 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1185 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1186 [The number of bytes in a time_t.])
1189 # if have pthread_t then define SIZEOF_PTHREAD_T
1191 if test "$ac_cv_kpthread" = "yes"
1192 then CC="$CC -Kpthread"
1193 elif test "$ac_cv_kthread" = "yes"
1194 then CC="$CC -Kthread"
1195 elif test "$ac_cv_pthread" = "yes"
1196 then CC="$CC -pthread"
1198 AC_MSG_CHECKING(for pthread_t)
1200 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1201 AC_MSG_RESULT($have_pthread_t)
1202 if test "$have_pthread_t" = yes ; then
1203 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1204 AC_MSG_CHECKING(size of pthread_t)
1205 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1206 [AC_TRY_RUN([#include <stdio.h>
1207 #include <pthread.h>
1210 FILE *f=fopen("conftestval", "w");
1212 fprintf(f, "%d\n", sizeof(pthread_t));
1215 ac_cv_sizeof_pthread_t=`cat conftestval`,
1216 ac_cv_sizeof_pthread_t=0,
1217 ac_cv_sizeof_pthread_t=4)
1219 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1220 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1221 [The number of bytes in a pthread_t.])
1225 AC_MSG_CHECKING(for --enable-toolbox-glue)
1226 AC_ARG_ENABLE(toolbox-glue,
1227 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1229 if test -z "$enable_toolbox_glue"
1231 case $ac_sys_system/$ac_sys_release in
1233 enable_toolbox_glue="yes";;
1235 enable_toolbox_glue="no";;
1238 case "$enable_toolbox_glue" in
1240 extra_machdep_objs="Python/mactoolboxglue.o"
1241 extra_undefs="-u _PyMac_Error"
1242 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1243 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1246 extra_machdep_objs=""
1250 AC_MSG_RESULT($enable_toolbox_glue)
1252 AC_SUBST(OTHER_LIBTOOL_OPT)
1253 case $ac_sys_system/$ac_sys_release in
1254 Darwin/@<:@01234567@:>@.*)
1255 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1258 OTHER_LIBTOOL_OPT=""
1262 AC_SUBST(LIBTOOL_CRUFT)
1263 case $ac_sys_system/$ac_sys_release in
1264 Darwin/@<:@01234567@:>@.*)
1265 LIBTOOL_CRUFT="-framework System -lcc_dynamic -arch_only ppc"
1266 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1267 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1269 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1270 if test ${gcc_version} '<' 4.0
1272 LIBTOOL_CRUFT="-lcc_dynamic"
1276 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -lSystem -lSystemStubs -arch_only ppc'
1277 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1278 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1281 AC_MSG_CHECKING(for --enable-framework)
1282 if test "$enable_framework"
1284 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1285 # -F. is needed to allow linking to the framework while
1286 # in the build location.
1287 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1288 [Define if you want to produce an OpenStep/Rhapsody framework
1289 (shared library plus accessory files).])
1295 AC_MSG_CHECKING(for dyld)
1296 case $ac_sys_system/$ac_sys_release in
1298 AC_DEFINE(WITH_DYLD, 1,
1299 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1300 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1301 linker (rld). Dyld is necessary to support frameworks.])
1302 AC_MSG_RESULT(always on for Darwin)
1309 # Set info about shared libraries.
1314 AC_SUBST(LINKFORSHARED)
1315 # SO is the extension of shared libraries `(including the dot!)
1316 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1320 case $ac_sys_system in
1326 # this might also be a termcap variable, see #610332
1328 echo '====================================================================='
1330 echo '+ WARNING: You have set SO in your environment. +'
1331 echo '+ Do you really mean to change the extension for shared libraries? +'
1332 echo '+ Continuing in 10 seconds to let you to ponder. +'
1334 echo '====================================================================='
1338 # LDSHARED is the ld *command* used to create shared library
1339 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1340 # (Shared libraries in this instance are shared modules to be loaded into
1341 # Python, as opposed to building Python itself as a shared library.)
1342 AC_MSG_CHECKING(LDSHARED)
1343 if test -z "$LDSHARED"
1345 case $ac_sys_system/$ac_sys_release in
1347 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1348 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1351 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1352 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1354 IRIX/5*) LDSHARED="ld -shared";;
1355 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1357 if test "$GCC" = "yes"
1358 then LDSHARED='$(CC) -shared'
1359 else LDSHARED='$(CC) -G';
1361 hp*|HP*) LDSHARED="ld -b";;
1362 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1364 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1365 if test "$enable_framework" ; then
1366 # Link against the framework. All externals should be defined.
1367 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1368 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1370 # No framework. Ignore undefined symbols, assuming they come from Python
1371 LDSHARED="$LDSHARED -undefined suppress"
1373 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1374 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1375 if test "$enable_framework" ; then
1376 # Link against the framework. All externals should be defined.
1377 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1378 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1380 # No framework, use the Python app as bundle-loader
1381 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1382 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1385 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1386 # This allows an extension to be used in any Python
1387 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
1388 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1389 if test ${MACOSX_DEPLOYMENT_TARGET-${cur_target}} '>' 10.2
1391 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1392 BLDSHARED="$LDSHARED"
1394 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1395 if test "$enable_framework" ; then
1396 # Link against the framework. All externals should be defined.
1397 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1398 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1400 # No framework, use the Python app as bundle-loader
1401 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1402 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1406 Linux*|GNU*) LDSHARED='$(CC) -shared';;
1407 BSD/OS*/4*) LDSHARED="gcc -shared";;
1409 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1411 LDSHARED="$CC -shared ${LDFLAGS}"
1413 LDSHARED="ld -Bshareable ${LDFLAGS}"
1415 NetBSD*) LDSHARED="cc -shared ${LDFLAGS}";;
1416 OpenUNIX*|UnixWare*)
1417 if test "$GCC" = "yes"
1418 then LDSHARED='$(CC) -shared'
1419 else LDSHARED='$(CC) -G'
1421 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1422 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1423 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1424 atheos*) LDSHARED="gcc -shared";;
1428 AC_MSG_RESULT($LDSHARED)
1429 BLDSHARED=${BLDSHARED-$LDSHARED}
1430 # CCSHARED are the C *flags* used to create objects to go into a shared
1431 # library (module) -- this is only needed for a few systems
1432 AC_MSG_CHECKING(CCSHARED)
1433 if test -z "$CCSHARED"
1435 case $ac_sys_system/$ac_sys_release in
1436 SunOS*) if test "$GCC" = yes;
1437 then CCSHARED="-fPIC";
1438 else CCSHARED="-xcode=pic32";
1440 hp*|HP*) if test "$GCC" = yes;
1441 then CCSHARED="-fPIC";
1444 Linux*|GNU*) CCSHARED="-fPIC";;
1445 BSD/OS*/4*) CCSHARED="-fpic";;
1446 FreeBSD*|NetBSD*|OpenBSD*) CCSHARED="-fPIC";;
1447 OpenUNIX*|UnixWare*)
1448 if test "$GCC" = "yes"
1449 then CCSHARED="-fPIC"
1450 else CCSHARED="-KPIC"
1453 if test "$GCC" = "yes"
1454 then CCSHARED="-fPIC"
1455 else CCSHARED="-Kpic -belf"
1457 Monterey*) CCSHARED="-G";;
1458 IRIX*/6*) case $CC in
1459 *gcc*) CCSHARED="-shared";;
1462 atheos*) CCSHARED="-fPIC";;
1465 AC_MSG_RESULT($CCSHARED)
1466 # LINKFORSHARED are the flags passed to the $(CC) command that links
1467 # the python executable -- this is only needed for a few systems
1468 AC_MSG_CHECKING(LINKFORSHARED)
1469 if test -z "$LINKFORSHARED"
1471 case $ac_sys_system/$ac_sys_release in
1472 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1474 LINKFORSHARED="-Wl,-E -Wl,+s";;
1475 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1476 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1477 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1478 # -u libsys_s pulls in all symbols in libsys
1480 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1482 # not used by the core itself but which needs to be in the core so
1483 # that dynamically loaded extension modules have access to it.
1484 # -prebind is no longer used, because it actually seems to give a
1485 # slowdown in stead of a speedup, maybe due to the large number of
1486 # dynamic loads Python does.
1488 LINKFORSHARED="$extra_undefs"
1489 if test "$enable_framework"
1491 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1493 LINKFORSHARED="$LINKFORSHARED";;
1494 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1495 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1496 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1497 FreeBSD*|NetBSD*|OpenBSD*)
1498 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1500 LINKFORSHARED="-Wl,--export-dynamic"
1502 SunOS/5*) case $CC in
1504 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1506 LINKFORSHARED="-Xlinker --export-dynamic"
1510 if test $enable_shared = "no"
1512 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1516 AC_MSG_RESULT($LINKFORSHARED)
1518 AC_SUBST(CFLAGSFORSHARED)
1519 AC_MSG_CHECKING(CFLAGSFORSHARED)
1520 if test ! "$LIBRARY" = "$LDLIBRARY"
1522 case $ac_sys_system in
1524 # Cygwin needs CCSHARED when building extension DLLs
1525 # but not when building the interpreter DLL.
1526 CFLAGSFORSHARED='';;
1528 CFLAGSFORSHARED='$(CCSHARED)'
1531 AC_MSG_RESULT($CFLAGSFORSHARED)
1533 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1534 # library (with --enable-shared).
1535 # For platforms on which shared libraries are not allowed to have unresolved
1536 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1537 # if it is not required, since it creates a dependency of the shared library
1538 # to LIBS. This, in turn, means that applications linking the shared libpython
1539 # don't need to link LIBS explicitly. The default should be only changed
1540 # on systems where this approach causes problems.
1542 AC_MSG_CHECKING(SHLIBS)
1543 case "$ac_sys_system" in
1547 AC_MSG_RESULT($SHLIBS)
1550 # checks for libraries
1551 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1552 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1554 # only check for sem_ini if thread support is requested
1555 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1556 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1557 # posix4 on Solaris 2.6
1558 # pthread (first!) on Linux
1561 # check if we need libintl for locale functions
1562 AC_CHECK_LIB(intl, textdomain,
1563 AC_DEFINE(WITH_LIBINTL, 1,
1564 [Define to 1 if libintl is needed for locale functions.]))
1566 # checks for system dependent C++ extensions support
1567 case "$ac_sys_system" in
1568 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1569 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1570 [loadAndInit("", 0, "")],
1571 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1572 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1573 and you want support for AIX C++ shared extension modules.])
1574 AC_MSG_RESULT(yes)],
1575 [AC_MSG_RESULT(no)]);;
1579 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1580 # BeOS' sockets are stashed in libnet.
1581 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1582 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1584 case "$ac_sys_system" in
1586 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1590 AC_MSG_CHECKING(for --with-libs)
1592 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1594 AC_MSG_RESULT($withval)
1595 LIBS="$withval $LIBS"
1597 [AC_MSG_RESULT(no)])
1599 # Determine if signalmodule should be used.
1600 AC_SUBST(USE_SIGNAL_MODULE)
1601 AC_SUBST(SIGNAL_OBJS)
1602 AC_MSG_CHECKING(for --with-signal-module)
1603 AC_ARG_WITH(signal-module,
1604 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1606 if test -z "$with_signal_module"
1607 then with_signal_module="yes"
1609 AC_MSG_RESULT($with_signal_module)
1611 if test "${with_signal_module}" = "yes"; then
1612 USE_SIGNAL_MODULE=""
1615 USE_SIGNAL_MODULE="#"
1616 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1619 # This is used to generate Setup.config
1620 AC_SUBST(USE_THREAD_MODULE)
1621 USE_THREAD_MODULE=""
1623 AC_MSG_CHECKING(for --with-dec-threads)
1625 AC_ARG_WITH(dec-threads,
1626 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1628 AC_MSG_RESULT($withval)
1630 if test "${with_thread+set}" != set; then
1631 with_thread="$withval";
1633 [AC_MSG_RESULT(no)])
1635 # Templates for things AC_DEFINEd more than once.
1636 # For a single AC_DEFINE, no template is needed.
1637 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1638 AH_TEMPLATE(_REENTRANT,
1639 [Define to force use of thread-safe errno, h_errno, and other functions])
1640 AH_TEMPLATE(WITH_THREAD,
1641 [Define if you want to compile in rudimentary thread support])
1643 AC_MSG_CHECKING(for --with-threads)
1644 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1645 AC_ARG_WITH(threads,
1646 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1648 # --with-thread is deprecated, but check for it anyway
1649 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1651 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1652 [with_threads=$with_thread])
1654 if test -z "$with_threads"
1655 then with_threads="yes"
1657 AC_MSG_RESULT($with_threads)
1660 if test "$with_threads" = "no"
1662 USE_THREAD_MODULE="#"
1663 elif test "$ac_cv_pthread_is_default" = yes
1665 AC_DEFINE(WITH_THREAD)
1666 # Defining _REENTRANT on system with POSIX threads should not hurt.
1667 AC_DEFINE(_REENTRANT)
1669 THREADOBJ="Python/thread.o"
1670 elif test "$ac_cv_kpthread" = "yes"
1673 if test "$ac_cv_cxx_thread" = "yes"; then
1674 CXX="$CXX -Kpthread"
1676 AC_DEFINE(WITH_THREAD)
1678 THREADOBJ="Python/thread.o"
1679 elif test "$ac_cv_kthread" = "yes"
1682 if test "$ac_cv_cxx_thread" = "yes"; then
1685 AC_DEFINE(WITH_THREAD)
1687 THREADOBJ="Python/thread.o"
1688 elif test "$ac_cv_pthread" = "yes"
1691 if test "$ac_cv_cxx_thread" = "yes"; then
1694 AC_DEFINE(WITH_THREAD)
1696 THREADOBJ="Python/thread.o"
1698 if test ! -z "$with_threads" -a -d "$with_threads"
1699 then LDFLAGS="$LDFLAGS -L$with_threads"
1701 if test ! -z "$withval" -a -d "$withval"
1702 then LDFLAGS="$LDFLAGS -L$withval"
1705 # According to the POSIX spec, a pthreads implementation must
1706 # define _POSIX_THREADS in unistd.h. Some apparently don't
1707 # (e.g. gnu pth with pthread emulation)
1708 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
1712 #ifdef _POSIX_THREADS
1715 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
1716 AC_MSG_RESULT($unistd_defines_pthreads)
1718 AC_DEFINE(_REENTRANT)
1719 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
1720 AC_DEFINE(C_THREADS)
1721 AC_DEFINE(HURD_C_THREADS, 1,
1722 [Define if you are using Mach cthreads directly under /include])
1723 LIBS="$LIBS -lthreads"
1724 THREADOBJ="Python/thread.o"],[
1725 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
1726 AC_DEFINE(C_THREADS)
1727 AC_DEFINE(MACH_C_THREADS, 1,
1728 [Define if you are using Mach cthreads under mach /])
1729 THREADOBJ="Python/thread.o"],[
1730 AC_MSG_CHECKING(for --with-pth)
1732 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
1733 [AC_MSG_RESULT($withval)
1734 AC_DEFINE([WITH_THREAD])
1735 AC_DEFINE([HAVE_PTH], 1,
1736 [Define if you have GNU PTH threads.])
1738 THREADOBJ="Python/thread.o"],
1741 # Just looking for pthread_create in libpthread is not enough:
1742 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
1743 # So we really have to include pthread.h, and then link.
1745 LIBS="$LIBS -lpthread"
1746 AC_MSG_CHECKING([for pthread_create in -lpthread])
1747 AC_TRY_LINK([#include <pthread.h>
1749 void * start_routine (void *arg) { exit (0); }], [
1750 pthread_create (NULL, NULL, start_routine, NULL)], [
1752 AC_DEFINE(WITH_THREAD)
1754 THREADOBJ="Python/thread.o"],[
1756 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
1758 THREADOBJ="Python/thread.o"],[
1759 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
1760 AC_DEFINE(ATHEOS_THREADS, 1,
1761 [Define this if you have AtheOS threads.])
1762 THREADOBJ="Python/thread.o"],[
1763 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
1764 AC_DEFINE(BEOS_THREADS, 1,
1765 [Define this if you have BeOS threads.])
1766 THREADOBJ="Python/thread.o"],[
1767 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
1769 LIBS="$LIBS -lpthreads"
1770 THREADOBJ="Python/thread.o"], [
1771 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
1774 THREADOBJ="Python/thread.o"], [
1775 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
1777 LIBS="$LIBS -lpthread"
1778 THREADOBJ="Python/thread.o"], [
1779 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
1782 THREADOBJ="Python/thread.o"],[
1783 USE_THREAD_MODULE="#"])
1784 ])])])])])])])])])])
1786 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
1788 THREADOBJ="Python/thread.o"
1789 USE_THREAD_MODULE=""])
1791 if test "$posix_threads" != "yes"; then
1792 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
1793 LIBS="$LIBS -lthread"
1794 THREADOBJ="Python/thread.o"
1795 USE_THREAD_MODULE=""])
1798 if test "$USE_THREAD_MODULE" != "#"
1800 # If the above checks didn't disable threads, (at least) OSF1
1801 # needs this '-threads' argument during linking.
1802 case $ac_sys_system in
1803 OSF1) LDLAST=-threads;;
1808 if test "$posix_threads" = "yes"; then
1809 if test "$unistd_defines_pthreads" = "no"; then
1810 AC_DEFINE(_POSIX_THREADS, 1,
1811 [Define if you have POSIX threads,
1812 and your system does not define that.])
1815 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
1816 case $ac_sys_system/$ac_sys_release in
1817 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
1818 Defined for Solaris 2.6 bug in pthread header.)
1820 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
1821 Define if the Posix semaphores do not work on your system)
1825 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
1826 AC_CACHE_VAL(ac_cv_pthread_system_supported,
1827 [AC_TRY_RUN([#include <pthread.h>
1828 void *foo(void *parm) {
1832 pthread_attr_t attr;
1834 if (pthread_attr_init(&attr)) exit(-1);
1835 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
1836 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
1839 ac_cv_pthread_system_supported=yes,
1840 ac_cv_pthread_system_supported=no,
1841 ac_cv_pthread_system_supported=no)
1843 AC_MSG_RESULT($ac_cv_pthread_system_supported)
1844 if test "$ac_cv_pthread_system_supported" = "yes"; then
1845 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
1847 AC_CHECK_FUNCS(pthread_sigmask,
1848 [case $ac_sys_system in
1850 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
1851 [Define if pthread_sigmask() does not work on your system.])
1857 # Check for enable-ipv6
1858 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
1859 AC_MSG_CHECKING([if --enable-ipv6 is specified])
1861 [ --enable-ipv6 Enable ipv6 (with ipv4) support
1862 --disable-ipv6 Disable ipv6 support],
1863 [ case "$enableval" in
1868 *) AC_MSG_RESULT(yes)
1869 AC_DEFINE(ENABLE_IPV6)
1875 dnl the check does not work on cross compilation case...
1876 AC_TRY_RUN([ /* AF_INET6 available check */
1877 #include <sys/types.h>
1878 #include <sys/socket.h>
1881 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
1895 if test "$ipv6" = "yes"; then
1896 AC_MSG_CHECKING(if RFC2553 API is available)
1897 AC_TRY_COMPILE([#include <sys/types.h>
1898 #include <netinet/in.h>],
1899 [struct sockaddr_in6 x;
1903 AC_MSG_RESULT(no, IPv6 disabled)
1907 if test "$ipv6" = "yes"; then
1908 AC_DEFINE(ENABLE_IPV6)
1916 if test "$ipv6" = "yes"; then
1917 AC_MSG_CHECKING([ipv6 stack type])
1918 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
1922 dnl http://www.kame.net/
1924 #include <netinet/in.h>
1925 #ifdef IPV6_INRIA_VERSION
1931 dnl http://www.kame.net/
1933 #include <netinet/in.h>
1939 ipv6libdir=/usr/local/v6/lib
1943 dnl http://www.v6.linux.or.jp/
1945 #include <features.h>
1946 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
1953 dnl http://www.v6.linux.or.jp/
1954 if test -d /usr/inet6; then
1957 ipv6libdir=/usr/inet6/lib
1958 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
1962 if test -f /etc/netconfig; then
1963 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
1971 #include <sys/param.h>
1972 #ifdef _TOSHIBA_INET6
1977 ipv6libdir=/usr/local/v6/lib])
1981 #include </usr/local/v6/include/sys/v6config.h>
1987 ipv6libdir=/usr/local/v6/lib;
1988 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
1992 #include <sys/param.h>
1993 #ifdef _ZETA_MINAMI_INET6
1998 ipv6libdir=/usr/local/v6/lib])
2001 if test "$ipv6type" != "unknown"; then
2005 AC_MSG_RESULT($ipv6type)
2008 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2009 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2010 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2011 echo "using lib$ipv6lib"
2013 if test $ipv6trylibc = "yes"; then
2016 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2017 echo "You need to fetch lib$ipv6lib.a from appropriate"
2018 echo 'ipv6 kit and compile beforehand.'
2024 # Check for --with-doc-strings
2025 AC_MSG_CHECKING(for --with-doc-strings)
2026 AC_ARG_WITH(doc-strings,
2027 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2029 if test -z "$with_doc_strings"
2030 then with_doc_strings="yes"
2032 if test "$with_doc_strings" != "no"
2034 AC_DEFINE(WITH_DOC_STRINGS, 1,
2035 [Define if you want documentation strings in extension modules])
2037 AC_MSG_RESULT($with_doc_strings)
2039 # Check for Python-specific malloc support
2040 AC_MSG_CHECKING(for --with-tsc)
2042 [ --with(out)-tsc enable/disable timestamp counter profile], [
2043 if test "$withval" != no
2045 AC_DEFINE(WITH_TSC, 1,
2046 [Define to profile with the Pentium timestamp counter])
2048 else AC_MSG_RESULT(no)
2050 [AC_MSG_RESULT(no)])
2052 # Check for Python-specific malloc support
2053 AC_MSG_CHECKING(for --with-pymalloc)
2054 AC_ARG_WITH(pymalloc,
2055 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2057 if test -z "$with_pymalloc"
2058 then with_pymalloc="yes"
2060 if test "$with_pymalloc" != "no"
2062 AC_DEFINE(WITH_PYMALLOC, 1,
2063 [Define if you want to compile in Python-specific mallocs])
2065 AC_MSG_RESULT($with_pymalloc)
2067 # Check for --with-wctype-functions
2068 AC_MSG_CHECKING(for --with-wctype-functions)
2069 AC_ARG_WITH(wctype-functions,
2070 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2072 if test "$withval" != no
2074 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2075 [Define if you want wctype.h functions to be used instead of the
2076 one supplied by Python itself. (see Include/unicodectype.h).])
2078 else AC_MSG_RESULT(no)
2080 [AC_MSG_RESULT(no)])
2082 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2086 # the dlopen() function means we might want to use dynload_shlib.o. some
2087 # platforms, such as AIX, have dlopen(), but don't want to use it.
2088 AC_CHECK_FUNCS(dlopen)
2090 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2091 # loading of modules.
2092 AC_SUBST(DYNLOADFILE)
2093 AC_MSG_CHECKING(DYNLOADFILE)
2094 if test -z "$DYNLOADFILE"
2096 case $ac_sys_system/$ac_sys_release in
2097 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2098 if test "$ac_cv_func_dlopen" = yes
2099 then DYNLOADFILE="dynload_shlib.o"
2100 else DYNLOADFILE="dynload_aix.o"
2103 BeOS*) DYNLOADFILE="dynload_beos.o";;
2104 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2105 Darwin/*) DYNLOADFILE="dynload_next.o";;
2106 atheos*) DYNLOADFILE="dynload_atheos.o";;
2108 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2109 # out any dynamic loading
2110 if test "$ac_cv_func_dlopen" = yes
2111 then DYNLOADFILE="dynload_shlib.o"
2112 else DYNLOADFILE="dynload_stub.o"
2117 AC_MSG_RESULT($DYNLOADFILE)
2118 if test "$DYNLOADFILE" != "dynload_stub.o"
2120 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2121 [Defined when any dynamic module loading is enabled.])
2124 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2126 AC_SUBST(MACHDEP_OBJS)
2127 AC_MSG_CHECKING(MACHDEP_OBJS)
2128 if test -z "$MACHDEP_OBJS"
2130 MACHDEP_OBJS=$extra_machdep_objs
2132 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2134 AC_MSG_RESULT(MACHDEP_OBJS)
2136 # checks for library functions
2137 AC_CHECK_FUNCS(alarm bind_textdomain_codeset chown clock confstr ctermid \
2138 execv fork fpathconf ftime ftruncate \
2139 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2140 getpriority getpwent getspnam getspent getsid getwd \
2141 kill killpg lchown lstat mkfifo mknod mktime \
2142 mremap nice pathconf pause plock poll pthread_init \
2143 putenv readlink realpath \
2144 select setegid seteuid setgid \
2145 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2146 sigaction siginterrupt sigrelse strftime \
2147 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2148 truncate uname unsetenv utimes waitpid wcscoll _getpty)
2150 # For some functions, having a definition is not sufficient, since
2151 # we want to take their address.
2152 AC_MSG_CHECKING(for chroot)
2153 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2154 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2158 AC_MSG_CHECKING(for link)
2159 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2160 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2164 AC_MSG_CHECKING(for symlink)
2165 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2166 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2170 AC_MSG_CHECKING(for fchdir)
2171 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2172 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2176 AC_MSG_CHECKING(for fsync)
2177 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2178 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2182 AC_MSG_CHECKING(for fdatasync)
2183 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2184 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2189 # On some systems (eg. FreeBSD 5), we would find a definition of the
2190 # functions ctermid_r, setgroups in the library, but no prototype
2191 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2192 # address to avoid compiler warnings and potential miscompilations
2193 # because of the missing prototypes.
2195 AC_MSG_CHECKING(for ctermid_r)
2197 #include "confdefs.h"
2199 ], void* p = ctermid_r,
2200 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2205 AC_MSG_CHECKING(for flock)
2207 #include "confdefs.h"
2208 #include <sys/file.h>
2210 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2215 AC_MSG_CHECKING(for getpagesize)
2217 #include "confdefs.h"
2219 ], void* p = getpagesize,
2220 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2226 AC_CHECK_PROGS(TRUE, true, /bin/true)
2228 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2229 dnl On others, they are in the C library, so we to take no action
2230 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2231 AC_CHECK_LIB(resolv, inet_aton)
2234 AC_MSG_CHECKING(for hstrerror)
2236 #include "confdefs.h"
2238 ], void* p = hstrerror; hstrerror(0),
2239 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2244 AC_MSG_CHECKING(for inet_aton)
2246 #include "confdefs.h"
2247 #include <sys/socket.h>
2248 #include <netinet/in.h>
2249 #include <arpa/inet.h>
2250 ], void* p = inet_aton;inet_aton(0,0),
2251 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2256 AC_MSG_CHECKING(for inet_pton)
2258 #include "confdefs.h"
2259 #include <sys/types.h>
2260 #include <sys/socket.h>
2261 #include <netinet/in.h>
2262 #include <arpa/inet.h>
2263 ], void* p = inet_pton,
2264 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2269 # On some systems, setgroups is in unistd.h, on others, in grp.h
2270 AC_MSG_CHECKING(for setgroups)
2272 #include "confdefs.h"
2278 void* p = setgroups,
2279 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2284 # check for openpty and forkpty
2286 AC_CHECK_FUNCS(openpty,,
2287 AC_CHECK_LIB(util,openpty,
2288 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2289 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2292 AC_CHECK_FUNCS(forkpty,,
2293 AC_CHECK_LIB(util,forkpty,
2294 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2295 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2299 # check for long file support functions
2300 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2302 AC_REPLACE_FUNCS(dup2 getcwd strdup strerror memmove)
2303 AC_CHECK_FUNCS(getpgrp,
2304 AC_TRY_COMPILE([#include <unistd.h>],
2306 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2307 [Define if getpgrp() must be called as getpgrp(0).])
2310 AC_CHECK_FUNCS(setpgrp,
2311 AC_TRY_COMPILE([#include <unistd.h>],
2313 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2314 [Define if setpgrp() must be called as setpgrp(0, 0).])
2317 AC_CHECK_FUNCS(gettimeofday,
2318 AC_TRY_COMPILE([#include <sys/time.h>],
2319 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2320 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2321 [Define if gettimeofday() does not have second (timezone) argument
2322 This is the case on Motorola V4 (R40V4.2)])
2326 AC_MSG_CHECKING(for major, minor, and makedev)
2328 #if defined(MAJOR_IN_MKDEV)
2329 #include <sys/mkdev.h>
2330 #elif defined(MAJOR_IN_SYSMACROS)
2331 #include <sys/sysmacros.h>
2333 #include <sys/types.h>
2336 makedev(major(0),minor(0));
2338 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2339 [Define to 1 if you have the device macros.])
2345 # On OSF/1 V5.1, getaddrinfo is available, but a define
2346 # for [no]getaddrinfo in netdb.h.
2347 AC_MSG_CHECKING(for getaddrinfo)
2349 #include <sys/types.h>
2350 #include <sys/socket.h>
2354 getaddrinfo(NULL, NULL, NULL, NULL);
2357 AC_MSG_CHECKING(getaddrinfo bug)
2359 #include <sys/types.h>
2362 #include <sys/socket.h>
2363 #include <netinet/in.h>
2367 int passive, gaierr, inet4 = 0, inet6 = 0;
2368 struct addrinfo hints, *ai, *aitop;
2369 char straddr[INET6_ADDRSTRLEN], strport[16];
2371 for (passive = 0; passive <= 1; passive++) {
2372 memset(&hints, 0, sizeof(hints));
2373 hints.ai_family = AF_UNSPEC;
2374 hints.ai_flags = passive ? AI_PASSIVE : 0;
2375 hints.ai_socktype = SOCK_STREAM;
2376 hints.ai_protocol = IPPROTO_TCP;
2377 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2378 (void)gai_strerror(gaierr);
2381 for (ai = aitop; ai; ai = ai->ai_next) {
2382 if (ai->ai_addr == NULL ||
2383 ai->ai_addrlen == 0 ||
2384 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2385 straddr, sizeof(straddr), strport, sizeof(strport),
2386 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2389 switch (ai->ai_family) {
2391 if (strcmp(strport, "54321") != 0) {
2395 if (strcmp(straddr, "0.0.0.0") != 0) {
2399 if (strcmp(straddr, "127.0.0.1") != 0) {
2406 if (strcmp(strport, "54321") != 0) {
2410 if (strcmp(straddr, "::") != 0) {
2414 if (strcmp(straddr, "::1") != 0) {
2424 /* another family support? */
2430 if (!(inet4 == 0 || inet4 == 2))
2432 if (!(inet6 == 0 || inet6 == 2))
2436 freeaddrinfo(aitop);
2441 freeaddrinfo(aitop);
2446 buggygetaddrinfo=no,
2447 AC_MSG_RESULT(buggy)
2448 buggygetaddrinfo=yes,
2449 AC_MSG_RESULT(buggy)
2450 buggygetaddrinfo=yes)], [
2452 buggygetaddrinfo=yes
2455 if test "$buggygetaddrinfo" = "yes"; then
2456 if test "$ipv6" = "yes"; then
2457 echo 'Fatal: You must get working getaddrinfo() function.'
2458 echo ' or you can specify "--disable-ipv6"'.
2462 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2464 AC_CHECK_FUNCS(getnameinfo)
2466 # checks for structures
2470 AC_CHECK_MEMBERS([struct stat.st_rdev])
2471 AC_CHECK_MEMBERS([struct stat.st_blksize])
2472 AC_CHECK_MEMBERS([struct stat.st_flags])
2473 AC_CHECK_MEMBERS([struct stat.st_gen])
2474 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2477 AC_MSG_CHECKING(for time.h that defines altzone)
2478 AC_CACHE_VAL(ac_cv_header_time_altzone,
2479 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2480 ac_cv_header_time_altzone=yes,
2481 ac_cv_header_time_altzone=no)])
2482 AC_MSG_RESULT($ac_cv_header_time_altzone)
2483 if test $ac_cv_header_time_altzone = yes; then
2484 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2488 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2490 #include <sys/types.h>
2491 #include <sys/select.h>
2492 #include <sys/time.h>
2494 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2495 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2496 (which you can't on SCO ODT 3.0).])
2499 AC_MSG_RESULT($was_it_defined)
2501 AC_MSG_CHECKING(for addrinfo)
2502 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2504 # include <netdb.h>],
2505 [struct addrinfo a],
2506 ac_cv_struct_addrinfo=yes,
2507 ac_cv_struct_addrinfo=no))
2508 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2509 if test $ac_cv_struct_addrinfo = yes; then
2510 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2513 AC_MSG_CHECKING(for sockaddr_storage)
2514 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2516 # include <sys/types.h>
2517 # include <sys/socket.h>],
2518 [struct sockaddr_storage s],
2519 ac_cv_struct_sockaddr_storage=yes,
2520 ac_cv_struct_sockaddr_storage=no))
2521 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2522 if test $ac_cv_struct_sockaddr_storage = yes; then
2523 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2526 # checks for compiler characteristics
2532 AC_MSG_CHECKING(for working volatile)
2533 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2534 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2536 AC_MSG_RESULT($works)
2539 AC_MSG_CHECKING(for working signed char)
2540 AC_TRY_COMPILE([], [signed char c;], works=yes,
2541 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2543 AC_MSG_RESULT($works)
2546 AC_MSG_CHECKING(for prototypes)
2547 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2548 AC_DEFINE(HAVE_PROTOTYPES, 1,
2549 [Define if your compiler supports function prototype])
2552 AC_MSG_RESULT($have_prototypes)
2555 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2558 int foo(int x, ...) {
2566 ], [return foo(10, "", 3.14);], [
2567 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2568 [Define if your compiler supports variable length function prototypes
2569 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2572 AC_MSG_RESULT($works)
2574 # check for socketpair
2575 AC_MSG_CHECKING(for socketpair)
2577 #include <sys/types.h>
2578 #include <sys/socket.h>
2579 ], void *x=socketpair,
2580 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2585 # check if sockaddr has sa_len member
2586 AC_MSG_CHECKING(if sockaddr has sa_len member)
2587 AC_TRY_COMPILE([#include <sys/types.h>
2588 #include <sys/socket.h>],
2592 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2596 AC_MSG_CHECKING(whether va_list is an array)
2598 #ifdef HAVE_STDARG_PROTOTYPES
2601 #include <varargs.h>
2603 ], [va_list list1, list2; list1 = list2;], , [
2604 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2605 va_list_is_array=yes
2607 AC_MSG_RESULT($va_list_is_array)
2609 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2610 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2611 [Define this if you have some version of gethostbyname_r()])
2613 AC_CHECK_FUNC(gethostbyname_r, [
2614 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2615 AC_MSG_CHECKING([gethostbyname_r with 6 args])
2617 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2622 struct hostent *he, *res;
2627 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2629 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2630 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
2631 [Define this if you have the 6-arg version of gethostbyname_r().])
2635 AC_MSG_CHECKING([gethostbyname_r with 5 args])
2645 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2647 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2648 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
2649 [Define this if you have the 5-arg version of gethostbyname_r().])
2653 AC_MSG_CHECKING([gethostbyname_r with 3 args])
2659 struct hostent_data data;
2661 (void) gethostbyname_r(name, he, &data);
2663 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2664 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
2665 [Define this if you have the 3-arg version of gethostbyname_r().])
2674 AC_CHECK_FUNCS(gethostbyname)
2676 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
2677 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
2678 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
2679 AC_SUBST(HAVE_GETHOSTBYNAME_R)
2680 AC_SUBST(HAVE_GETHOSTBYNAME)
2682 # checks for system services
2685 # Linux requires this for correct f.p. operations
2686 AC_CHECK_FUNC(__fpu_control,
2688 [AC_CHECK_LIB(ieee, __fpu_control)
2691 # Check for --with-fpectl
2692 AC_MSG_CHECKING(for --with-fpectl)
2694 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
2696 if test "$withval" != no
2698 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
2699 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
2701 else AC_MSG_RESULT(no)
2703 [AC_MSG_RESULT(no)])
2705 # check for --with-libm=...
2707 case $ac_sys_system in
2712 AC_MSG_CHECKING(for --with-libm=STRING)
2714 AC_HELP_STRING(--with-libm=STRING, math library),
2716 if test "$withval" = no
2718 AC_MSG_RESULT(force LIBM empty)
2719 elif test "$withval" != yes
2721 AC_MSG_RESULT(set LIBM="$withval")
2722 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
2724 [AC_MSG_RESULT(default LIBM="$LIBM")])
2726 # check for --with-libc=...
2728 AC_MSG_CHECKING(for --with-libc=STRING)
2730 AC_HELP_STRING(--with-libc=STRING, C library),
2732 if test "$withval" = no
2734 AC_MSG_RESULT(force LIBC empty)
2735 elif test "$withval" != yes
2737 AC_MSG_RESULT(set LIBC="$withval")
2738 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
2740 [AC_MSG_RESULT(default LIBC="$LIBC")])
2742 # check for hypot() in math library
2745 AC_REPLACE_FUNCS(hypot)
2749 AC_CHECK_HEADER(wchar.h, [
2750 AC_DEFINE(HAVE_WCHAR_H, 1,
2751 [Define if the compiler provides a wchar.h header file.])
2757 # determine wchar_t size
2758 if test "$wchar_h" = yes
2760 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
2763 AC_MSG_CHECKING(for UCS-4 tcl)
2767 #if TCL_UTF_MAX != 6
2768 # error "NOT UCS4_TCL"
2770 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
2773 AC_MSG_RESULT($have_ucs4_tcl)
2775 # check whether wchar_t is signed or not
2776 if test "$wchar_h" = yes
2778 # check whether wchar_t is signed or not
2779 AC_MSG_CHECKING(whether wchar_t is signed)
2780 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
2785 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 1 : 0);
2788 ac_cv_wchar_t_signed=yes,
2789 ac_cv_wchar_t_signed=no,
2790 ac_cv_wchar_t_signed=yes)])
2791 AC_MSG_RESULT($ac_cv_wchar_t_signed)
2794 AC_MSG_CHECKING(what type to use for unicode)
2795 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2796 AC_ARG_ENABLE(unicode,
2797 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
2799 [enable_unicode=yes])
2801 if test $enable_unicode = yes
2803 # Without any arguments, Py_UNICODE defaults to two-byte mode
2804 case "$have_ucs4_tcl" in
2805 yes) enable_unicode="ucs4"
2807 *) enable_unicode="ucs2"
2812 AH_TEMPLATE(Py_UNICODE_SIZE,
2813 [Define as the size of the unicode type.])
2814 case "$enable_unicode" in
2815 ucs2) unicode_size="2"
2816 AC_DEFINE(Py_UNICODE_SIZE,2)
2818 ucs4) unicode_size="4"
2819 AC_DEFINE(Py_UNICODE_SIZE,4)
2823 AH_TEMPLATE(PY_UNICODE_TYPE,
2824 [Define as the integral type used for Unicode representation.])
2826 AC_SUBST(UNICODE_OBJS)
2827 if test "$enable_unicode" = "no"
2830 AC_MSG_RESULT(not used)
2832 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
2833 AC_DEFINE(Py_USING_UNICODE, 1,
2834 [Define if you want to have a Unicode type.])
2836 # wchar_t is only usable if it maps to an unsigned type
2837 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
2838 -a "$ac_cv_wchar_t_signed" = "no"
2840 PY_UNICODE_TYPE="wchar_t"
2841 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
2842 [Define if you have a useable wchar_t type defined in wchar.h; useable
2843 means wchar_t must be an unsigned type with at least 16 bits. (see
2844 Include/unicodeobject.h).])
2845 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
2846 elif test "$ac_cv_sizeof_short" = "$unicode_size"
2848 PY_UNICODE_TYPE="unsigned short"
2849 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
2850 elif test "$ac_cv_sizeof_long" = "$unicode_size"
2852 PY_UNICODE_TYPE="unsigned long"
2853 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
2855 PY_UNICODE_TYPE="no type found"
2857 AC_MSG_RESULT($PY_UNICODE_TYPE)
2860 # check for endianness
2863 # Check whether right shifting a negative integer extends the sign bit
2864 # or fills with zeros (like the Cray J90, according to Tim Peters).
2865 AC_MSG_CHECKING(whether right shift extends the sign bit)
2866 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
2870 exit(((-1)>>3 == -1) ? 0 : 1);
2873 ac_cv_rshift_extends_sign=yes,
2874 ac_cv_rshift_extends_sign=no,
2875 ac_cv_rshift_extends_sign=yes)])
2876 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
2877 if test "$ac_cv_rshift_extends_sign" = no
2879 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
2880 [Define if i>>j for signed int i does not extend the sign bit
2884 # check for getc_unlocked and related locking functions
2885 AC_MSG_CHECKING(for getc_unlocked() and friends)
2886 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
2887 AC_TRY_LINK([#include <stdio.h>],[
2888 FILE *f = fopen("/dev/null", "r");
2892 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
2893 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
2894 if test "$ac_cv_have_getc_unlocked" = yes
2896 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
2897 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
2900 # check where readline lives
2901 AC_CHECK_LIB(readline, readline)
2902 if test "$ac_cv_have_readline_readline" = no
2904 AC_CHECK_LIB(termcap, readline)
2907 # check for readline 2.1
2908 AC_CHECK_LIB(readline, rl_callback_handler_install,
2909 AC_DEFINE(HAVE_RL_CALLBACK, 1,
2910 [Define if you have readline 2.1]), , )
2912 # check for readline 2.2
2913 AC_TRY_CPP([#include <readline/readline.h>],
2914 have_readline=yes, have_readline=no)
2915 if test $have_readline = yes
2917 AC_EGREP_HEADER([extern int rl_completion_append_character;],
2918 [readline/readline.h],
2919 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
2920 [Define if you have readline 2.2]), )
2923 # check for readline 4.0
2924 AC_CHECK_LIB(readline, rl_pre_input_hook,
2925 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
2926 [Define if you have readline 4.0]), , )
2928 # check for readline 4.2
2929 AC_CHECK_LIB(readline, rl_completion_matches,
2930 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
2931 [Define if you have readline 4.2]), , )
2933 # also in readline 4.2
2934 AC_TRY_CPP([#include <readline/readline.h>],
2935 have_readline=yes, have_readline=no)
2936 if test $have_readline = yes
2938 AC_EGREP_HEADER([extern int rl_catch_signals;],
2939 [readline/readline.h],
2940 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
2941 [Define if you can turn off readline's signal handling.]), )
2944 AC_MSG_CHECKING(for broken nice())
2945 AC_CACHE_VAL(ac_cv_broken_nice, [
2950 if (val1 != -1 && val1 == nice(2))
2955 ac_cv_broken_nice=yes,
2956 ac_cv_broken_nice=no,
2957 ac_cv_broken_nice=no)])
2958 AC_MSG_RESULT($ac_cv_broken_nice)
2959 if test "$ac_cv_broken_nice" = yes
2961 AC_DEFINE(HAVE_BROKEN_NICE, 1,
2962 [Define if nice() returns success/failure instead of the new priority.])
2965 AC_MSG_CHECKING(for broken poll())
2971 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
2975 int poll_test = poll (&poll_struct, 1, 0);
2981 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
2991 ac_cv_broken_poll=yes,
2992 ac_cv_broken_poll=no,
2993 ac_cv_broken_poll=no)
2994 AC_MSG_RESULT($ac_cv_broken_poll)
2995 if test "$ac_cv_broken_poll" = yes
2997 AC_DEFINE(HAVE_BROKEN_POLL, 1,
2998 [Define if poll() sets errno on invalid file descriptors.])
3001 # Before we can test tzset, we need to check if struct tm has a tm_zone
3002 # (which is not required by ISO C or UNIX spec) and/or if we support
3006 # check tzset(3) exists and works like we expect it to
3007 AC_MSG_CHECKING(for working tzset())
3008 AC_CACHE_VAL(ac_cv_working_tzset, [
3015 extern char *tzname[];
3020 /* Note that we need to ensure that not only does tzset(3)
3021 do 'something' with localtime, but it works as documented
3022 in the library reference and as expected by the test suite.
3023 This includes making sure that tzname is set properly if
3024 tm->tm_zone does not exist since it is the alternative way
3025 of getting timezone info.
3027 Red Hat 6.2 doesn't understand the southern hemisphere
3028 after New Year's Day.
3031 time_t groundhogday = 1044144000; /* GMT-based */
3032 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3036 if (localtime(&groundhogday)->tm_hour != 0)
3039 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3040 if (strcmp(tzname[0], "UTC") ||
3041 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3045 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3047 if (localtime(&groundhogday)->tm_hour != 19)
3050 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3054 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3056 if (localtime(&groundhogday)->tm_hour != 11)
3059 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3063 #if HAVE_STRUCT_TM_TM_ZONE
3064 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3066 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3073 ac_cv_working_tzset=yes,
3074 ac_cv_working_tzset=no,
3075 ac_cv_working_tzset=no)])
3076 AC_MSG_RESULT($ac_cv_working_tzset)
3077 if test "$ac_cv_working_tzset" = yes
3079 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3080 [Define if tzset() actually switches the local timezone in a meaningful way.])
3083 # Look for subsecond timestamps in struct stat
3084 AC_MSG_CHECKING(for tv_nsec in struct stat)
3085 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3086 AC_TRY_COMPILE([#include <sys/stat.h>], [
3088 st.st_mtim.tv_nsec = 1;
3090 ac_cv_stat_tv_nsec=yes,
3091 ac_cv_stat_tv_nsec=no,
3092 ac_cv_stat_tv_nsec=no))
3093 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3094 if test "$ac_cv_stat_tv_nsec" = yes
3096 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3097 [Define if you have struct stat.st_mtim.tv_nsec])
3100 # Look for BSD style subsecond timestamps in struct stat
3101 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3102 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3103 AC_TRY_COMPILE([#include <sys/stat.h>], [
3105 st.st_mtimespec.tv_nsec = 1;
3107 ac_cv_stat_tv_nsec2=yes,
3108 ac_cv_stat_tv_nsec2=no,
3109 ac_cv_stat_tv_nsec2=no))
3110 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3111 if test "$ac_cv_stat_tv_nsec2" = yes
3113 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3114 [Define if you have struct stat.st_mtimensec])
3117 # On HP/UX 11.0, mvwdelch is a block with a return statement
3118 AC_MSG_CHECKING(whether mvwdelch is an expression)
3119 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3120 AC_TRY_COMPILE([#include <curses.h>], [
3122 rtn = mvwdelch(0,0,0);
3123 ], ac_cv_mvwdelch_is_expression=yes,
3124 ac_cv_mvwdelch_is_expression=no,
3125 ac_cv_mvwdelch_is_expression=yes))
3126 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3128 if test "$ac_cv_mvwdelch_is_expression" = yes
3130 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3131 [Define if mvwdelch in curses.h is an expression.])
3134 AC_MSG_CHECKING(whether WINDOW has _flags)
3135 AC_CACHE_VAL(ac_cv_window_has_flags,
3136 AC_TRY_COMPILE([#include <curses.h>], [
3139 ], ac_cv_window_has_flags=yes,
3140 ac_cv_window_has_flags=no,
3141 ac_cv_window_has_flags=no))
3142 AC_MSG_RESULT($ac_cv_window_has_flags)
3145 if test "$ac_cv_window_has_flags" = yes
3147 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3148 [Define if WINDOW in curses.h offers a field _flags.])
3151 AC_MSG_CHECKING(for /dev/ptmx)
3153 if test -e /dev/ptmx
3156 AC_DEFINE(HAVE_DEV_PTMX, 1,
3157 [Define if we have /dev/ptmx.])
3162 AC_MSG_CHECKING(for /dev/ptc)
3167 AC_DEFINE(HAVE_DEV_PTC, 1,
3168 [Define if we have /dev/ptc.])
3173 AC_CHECK_TYPE(socklen_t,,
3174 AC_DEFINE(socklen_t,int,
3175 Define to `int' if <sys/socket.h> does not define.),[
3176 #ifdef HAVE_SYS_TYPES_H
3177 #include <sys/types.h>
3179 #ifdef HAVE_SYS_SOCKET_H
3180 #include <sys/socket.h>
3184 AC_SUBST(THREADHEADERS)
3186 for h in `(cd $srcdir;echo Python/thread_*.h)`
3188 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3192 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3193 AC_MSG_CHECKING(for build directories)
3194 for dir in $SRCDIRS; do
3195 if test ! -d $dir; then
3201 # generate output files
3202 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3205 echo "creating Setup"
3206 if test ! -f Modules/Setup
3208 cp $srcdir/Modules/Setup.dist Modules/Setup
3211 echo "creating Setup.local"
3212 if test ! -f Modules/Setup.local
3214 echo "# Edit this file for local setup changes" >Modules/Setup.local
3217 echo "creating Makefile"
3218 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3219 -s Modules Modules/Setup.config \
3220 Modules/Setup.local Modules/Setup