| blob | 40fa044ba86cabc3e875c59cb38c827103a3cc3b |
1 dnl ***********************************************
2 dnl * Please run autoreconf to test your changes! *
3 dnl ***********************************************
4 dnl NOTE: autoconf 2.64 doesn't seem to work (use 2.61).
6 # Set VERSION so we only need to edit in one place (i.e., here)
7 m4_define(PYTHON_VERSION, 3.1)
9 AC_REVISION($Revision$)
10 AC_PREREQ(2.61)
11 AC_INIT(python, PYTHON_VERSION, http://www.python.org/python-bugs)
12 AC_CONFIG_SRCDIR([Include/object.h])
13 AC_CONFIG_HEADER(pyconfig.h)
15 dnl Ensure that if prefix is specified, it does not end in a slash. If
16 dnl it does, we get path names containing '//' which is both ugly and
17 dnl can cause trouble.
19 dnl Last slash shouldn't be stripped if prefix=/
20 if test "$prefix" != "/"; then
21 prefix=`echo "$prefix" | sed -e 's/\/$//g'`
22 fi
24 dnl This is for stuff that absolutely must end up in pyconfig.h.
25 dnl Please use pyport.h instead, if possible.
26 AH_TOP([
27 #ifndef Py_PYCONFIG_H
28 #define Py_PYCONFIG_H
29 ])
30 AH_BOTTOM([
31 /* Define the macros needed if on a UnixWare 7.x system. */
32 #if defined(__USLC__) && defined(__SCO_VERSION__)
33 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
34 #endif
36 #endif /*Py_PYCONFIG_H*/
37 ])
39 # We don't use PACKAGE_ variables, and they cause conflicts
40 # with other autoconf-based packages that include Python.h
41 grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
42 rm confdefs.h
43 mv confdefs.h.new confdefs.h
45 AC_SUBST(VERSION)
46 VERSION=PYTHON_VERSION
48 AC_SUBST(SOVERSION)
49 SOVERSION=1.0
51 # The later defininition of _XOPEN_SOURCE disables certain features
52 # on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
53 AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])
55 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
56 # certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
57 # them.
58 AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])
60 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
61 # certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
62 # them.
63 AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])
65 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
66 # u_int on Irix 5.3. Defining _BSD_TYPES brings it back.
67 AC_DEFINE(_BSD_TYPES, 1, [Define on Irix to enable u_int])
69 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
70 # certain features on Mac OS X, so we need _DARWIN_C_SOURCE to re-enable
71 # them.
72 AC_DEFINE(_DARWIN_C_SOURCE, 1, [Define on Darwin to activate all library features])
75 define_xopen_source=yes
77 # Arguments passed to configure.
78 AC_SUBST(CONFIG_ARGS)
79 CONFIG_ARGS="$ac_configure_args"
81 AC_ARG_ENABLE(universalsdk,
82 AC_HELP_STRING(--enable-universalsdk@<:@=SDKDIR@:>@, Build against Mac OS X 10.4u SDK (ppc/i386)),
83 [
84 case $enableval in
85 yes)
86 enableval=/Developer/SDKs/MacOSX10.4u.sdk
87 ;;
88 esac
89 case $enableval in
90 no)
91 UNIVERSALSDK=
92 enable_universalsdk=
93 ;;
94 *)
95 UNIVERSALSDK=$enableval
96 ;;
97 esac
98 ],[
99 UNIVERSALSDK=
100 enable_universalsdk=
101 ])
102 AC_SUBST(UNIVERSALSDK)
104 ARCH_RUN_32BIT=
105 AC_SUBST(ARCH_RUN_32BIT)
107 UNIVERSAL_ARCHS="32-bit"
108 AC_MSG_CHECKING(for --with-universal-archs)
109 AC_ARG_WITH(universal-archs,
110 AC_HELP_STRING(--with-universal-archs=ARCH, select architectures for universal build ("32-bit", "64-bit" or "all")),
111 [
112 AC_MSG_RESULT($withval)
113 UNIVERSAL_ARCHS="$withval"
114 ],
115 [
116 AC_MSG_RESULT(32-bit)
117 ])
121 AC_ARG_WITH(framework-name,
122 AC_HELP_STRING(--with-framework-name=FRAMEWORK,
123 specify an alternate name of the framework built with --enable-framework),
124 [
125 PYTHONFRAMEWORK=${withval}
126 PYTHONFRAMEWORKDIR=${withval}.framework
127 PYTHONFRAMEWORKIDENTIFIER=org.python.`echo $withval | tr '[A-Z]' '[a-z]'`
128 ],[
129 PYTHONFRAMEWORK=Python
130 PYTHONFRAMEWORKDIR=Python.framework
131 PYTHONFRAMEWORKIDENTIFIER=org.python.python
132 ])
133 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
134 AC_ARG_ENABLE(framework,
135 AC_HELP_STRING(--enable-framework@<:@=INSTALLDIR@:>@, Build (MacOSX|Darwin) framework),
136 [
137 case $enableval in
138 yes)
139 enableval=/Library/Frameworks
140 esac
141 case $enableval in
142 no)
143 PYTHONFRAMEWORK=
144 PYTHONFRAMEWORKDIR=no-framework
145 PYTHONFRAMEWORKPREFIX=
146 PYTHONFRAMEWORKINSTALLDIR=
147 FRAMEWORKINSTALLFIRST=
148 FRAMEWORKINSTALLLAST=
149 FRAMEWORKALTINSTALLFIRST=
150 FRAMEWORKALTINSTALLLAST=
151 if test "x${prefix}" = "xNONE"; then
152 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
153 else
154 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
155 fi
156 enable_framework=
157 ;;
158 *)
159 PYTHONFRAMEWORKPREFIX=$enableval
160 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
161 FRAMEWORKINSTALLFIRST="frameworkinstallstructure"
162 FRAMEWORKALTINSTALLFIRST="frameworkinstallstructure bininstall maninstall"
163 if test "$UNIVERSAL_ARCHS" = "all"
164 then
165 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps4way frameworkinstallunixtools4way"
166 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps4way frameworkaltinstallunixtools4way"
167 else
168 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools"
169 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkaltinstallunixtools"
170 fi
172 if test "x${prefix}" = "xNONE" ; then
173 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
174 else
175 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
176 fi
177 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
179 # Add files for Mac specific code to the list of output
180 # files:
181 AC_CONFIG_FILES(Mac/Makefile)
182 AC_CONFIG_FILES(Mac/PythonLauncher/Makefile)
183 AC_CONFIG_FILES(Mac/Resources/framework/Info.plist)
184 AC_CONFIG_FILES(Mac/Resources/app/Info.plist)
185 esac
186 ],[
187 PYTHONFRAMEWORK=
188 PYTHONFRAMEWORKDIR=no-framework
189 PYTHONFRAMEWORKPREFIX=
190 PYTHONFRAMEWORKINSTALLDIR=
191 FRAMEWORKINSTALLFIRST=
192 FRAMEWORKINSTALLLAST=
193 FRAMEWORKALTINSTALLFIRST=
194 FRAMEWORKALTINSTALLLAST=
195 if test "x${prefix}" = "xNONE" ; then
196 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
197 else
198 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
199 fi
200 enable_framework=
202 if test "$UNIVERSAL_ARCHS" = "all"
203 then
204 FRAMEWORKINSTALLLAST=update4wayuniversal
205 FRAMEWORKALTINSTALLLAST=update4wayuniversal
206 fi
207 ])
208 AC_SUBST(PYTHONFRAMEWORK)
209 AC_SUBST(PYTHONFRAMEWORKIDENTIFIER)
210 AC_SUBST(PYTHONFRAMEWORKDIR)
211 AC_SUBST(PYTHONFRAMEWORKPREFIX)
212 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
213 AC_SUBST(FRAMEWORKINSTALLFIRST)
214 AC_SUBST(FRAMEWORKINSTALLLAST)
215 AC_SUBST(FRAMEWORKALTINSTALLFIRST)
216 AC_SUBST(FRAMEWORKALTINSTALLLAST)
217 AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX)
219 ##AC_ARG_WITH(dyld,
220 ## AC_HELP_STRING(--with-dyld,
221 ## Use (OpenStep|Rhapsody) dynamic linker))
222 ##
223 # Set name for machine-dependent library files
224 AC_SUBST(MACHDEP)
225 AC_MSG_CHECKING(MACHDEP)
226 if test -z "$MACHDEP"
227 then
228 ac_sys_system=`uname -s`
229 if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64" \
230 -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
231 ac_sys_release=`uname -v`
232 else
233 ac_sys_release=`uname -r`
234 fi
235 ac_md_system=`echo $ac_sys_system |
236 tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
237 ac_md_release=`echo $ac_sys_release |
238 tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
239 MACHDEP="$ac_md_system$ac_md_release"
241 case $MACHDEP in
242 cygwin*) MACHDEP="cygwin";;
243 darwin*) MACHDEP="darwin";;
244 atheos*) MACHDEP="atheos";;
245 irix646) MACHDEP="irix6";;
246 '') MACHDEP="unknown";;
247 esac
248 fi
250 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
251 # disable features if it is defined, without any means to access these
252 # features as extensions. For these systems, we skip the definition of
253 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
254 # some feature, make sure there is no alternative way to access this
255 # feature. Also, when using wildcards, make sure you have verified the
256 # need for not defining _XOPEN_SOURCE on all systems matching the
257 # wildcard, and that the wildcard does not include future systems
258 # (which may remove their limitations).
259 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
260 case $ac_sys_system/$ac_sys_release in
261 # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
262 # even though select is a POSIX function. Reported by J. Ribbens.
263 # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
264 OpenBSD/2.* | OpenBSD/3.@<:@0123456789@:>@ | OpenBSD/4.@<:@0123@:>@)
265 define_xopen_source=no
266 # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
267 # also defined. This can be overridden by defining _BSD_SOURCE
268 # As this has a different meaning on Linux, only define it on OpenBSD
269 AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
270 ;;
271 # Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
272 # _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
273 # Marc Recht
274 NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6@<:@A-S@:>@)
275 define_xopen_source=no;;
276 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
277 # of union __?sigval. Reported by Stuart Bishop.
278 SunOS/5.6)
279 define_xopen_source=no;;
280 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
281 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
282 # Reconfirmed for 7.1.4 by Martin v. Loewis.
283 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
284 define_xopen_source=no;;
285 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
286 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
287 SCO_SV/3.2)
288 define_xopen_source=no;;
289 # On FreeBSD 4, the math functions C89 does not cover are never defined
290 # with _XOPEN_SOURCE and __BSD_VISIBLE does not re-enable them.
291 FreeBSD/4.*)
292 define_xopen_source=no;;
293 # On MacOS X 10.2, a bug in ncurses.h means that it craps out if
294 # _XOPEN_EXTENDED_SOURCE is defined. Apparently, this is fixed in 10.3, which
295 # identifies itself as Darwin/7.*
296 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
297 # disables platform specific features beyond repair.
298 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
299 # has no effect, don't bother defining them
300 Darwin/@<:@6789@:>@.*)
301 define_xopen_source=no;;
302 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
303 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
304 # or has another value. By not (re)defining it, the defaults come in place.
305 AIX/4)
306 define_xopen_source=no;;
307 AIX/5)
308 if test `uname -r` -eq 1; then
309 define_xopen_source=no
310 fi
311 ;;
312 # On QNX 6.3.2, defining _XOPEN_SOURCE prevents netdb.h from
313 # defining NI_NUMERICHOST.
314 QNX/6.3.2)
315 define_xopen_source=no
316 ;;
318 esac
320 if test $define_xopen_source = yes
321 then
322 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
323 # defined precisely as g++ defines it
324 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
325 # compiler
326 case $ac_sys_system/$ac_sys_release in
327 SunOS/5.8|SunOS/5.9|SunOS/5.10)
328 AC_DEFINE(_XOPEN_SOURCE, 500,
329 Define to the level of X/Open that your system supports)
330 ;;
331 *)
332 AC_DEFINE(_XOPEN_SOURCE, 600,
333 Define to the level of X/Open that your system supports)
334 ;;
335 esac
337 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
338 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
339 # several APIs are not declared. Since this is also needed in some
340 # cases for HP-UX, we define it globally.
341 # except for Solaris 10, where it must not be defined,
342 # as it implies XPG4.2
343 case $ac_sys_system/$ac_sys_release in
344 SunOS/5.10)
345 ;;
346 *)
347 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
348 Define to activate Unix95-and-earlier features)
349 ;;
350 esac
352 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
354 fi
356 #
357 # SGI compilers allow the specification of the both the ABI and the
358 # ISA on the command line. Depending on the values of these switches,
359 # different and often incompatable code will be generated.
360 #
361 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
362 # thus supply support for various ABI/ISA combinations. The MACHDEP
363 # variable is also adjusted.
364 #
365 AC_SUBST(SGI_ABI)
366 if test ! -z "$SGI_ABI"
367 then
368 CC="cc $SGI_ABI"
369 LDFLAGS="$SGI_ABI $LDFLAGS"
370 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
371 fi
372 AC_MSG_RESULT($MACHDEP)
374 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
375 # it may influence the way we can build extensions, so distutils
376 # needs to check it
377 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
378 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
379 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
380 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
382 AC_MSG_CHECKING(machine type as reported by uname -m)
383 ac_sys_machine=`uname -m`
384 AC_MSG_RESULT($ac_sys_machine)
386 # checks for alternative programs
388 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
389 # for debug/optimization stuff. BASECFLAGS is for flags that are required
390 # just to get things to compile and link. Users are free to override OPT
391 # when running configure or make. The build should not break if they do.
392 # BASECFLAGS should generally not be messed with, however.
394 # XXX shouldn't some/most/all of this code be merged with the stuff later
395 # on that fiddles with OPT and BASECFLAGS?
396 AC_MSG_CHECKING(for --without-gcc)
397 AC_ARG_WITH(gcc,
398 AC_HELP_STRING(--without-gcc,never use gcc),
399 [
400 case $withval in
401 no) CC=${CC:-cc}
402 without_gcc=yes;;
403 yes) CC=gcc
404 without_gcc=no;;
405 *) CC=$withval
406 without_gcc=$withval;;
407 esac], [
408 case $ac_sys_system in
409 AIX*) CC=cc_r
410 without_gcc=;;
411 Monterey*)
412 RANLIB=:
413 without_gcc=;;
414 *) without_gcc=no;;
415 esac])
416 AC_MSG_RESULT($without_gcc)
418 # If the user switches compilers, we can't believe the cache
419 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
420 then
421 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
422 (it is also a good idea to do 'make clean' before compiling)])
423 fi
425 AC_PROG_CC
427 AC_SUBST(CXX)
428 AC_SUBST(MAINCC)
429 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
430 AC_ARG_WITH(cxx_main,
431 AC_HELP_STRING([--with-cxx-main=<compiler>],
432 [compile main() and link python executable with C++ compiler]),
433 [
435 case $withval in
436 no) with_cxx_main=no
437 MAINCC='$(CC)';;
438 yes) with_cxx_main=yes
439 MAINCC='$(CXX)';;
440 *) with_cxx_main=yes
441 MAINCC=$withval
442 if test -z "$CXX"
443 then
444 CXX=$withval
445 fi;;
446 esac], [
447 with_cxx_main=no
448 MAINCC='$(CC)'
449 ])
450 AC_MSG_RESULT($with_cxx_main)
452 preset_cxx="$CXX"
453 if test -z "$CXX"
454 then
455 case "$CC" in
456 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
457 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
458 esac
459 if test "$CXX" = "notfound"
460 then
461 CXX=""
462 fi
463 fi
464 if test -z "$CXX"
465 then
466 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
467 if test "$CXX" = "notfound"
468 then
469 CXX=""
470 fi
471 fi
472 if test "$preset_cxx" != "$CXX"
473 then
474 AC_MSG_WARN([
476 By default, distutils will build C++ extension modules with "$CXX".
477 If this is not intended, then set CXX on the configure command line.
478 ])
479 fi
482 # checks for UNIX variants that set C preprocessor variables
483 AC_AIX
485 # Check for unsupported systems
486 case $ac_sys_system/$ac_sys_release in
487 atheos*|Linux*/1*)
488 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
489 echo See README for details.
490 exit 1;;
491 esac
493 AC_EXEEXT
494 AC_MSG_CHECKING(for --with-suffix)
495 AC_ARG_WITH(suffix,
496 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
497 [
498 case $withval in
499 no) EXEEXT=;;
500 yes) EXEEXT=.exe;;
501 *) EXEEXT=$withval;;
502 esac])
503 AC_MSG_RESULT($EXEEXT)
505 # Test whether we're running on a non-case-sensitive system, in which
506 # case we give a warning if no ext is given
507 AC_SUBST(BUILDEXEEXT)
508 AC_MSG_CHECKING(for case-insensitive build directory)
509 if test ! -d CaseSensitiveTestDir; then
510 mkdir CaseSensitiveTestDir
511 fi
513 if test -d casesensitivetestdir
514 then
515 AC_MSG_RESULT(yes)
516 BUILDEXEEXT=.exe
517 else
518 AC_MSG_RESULT(no)
519 BUILDEXEEXT=$EXEEXT
520 fi
521 rmdir CaseSensitiveTestDir
523 case $MACHDEP in
524 bsdos*)
525 case $CC in
526 gcc) CC="$CC -D_HAVE_BSDI";;
527 esac;;
528 esac
530 case $ac_sys_system in
531 hp*|HP*)
532 case $CC in
533 cc|*/cc) CC="$CC -Ae";;
534 esac;;
535 Monterey*)
536 case $CC in
537 cc) CC="$CC -Wl,-Bexport";;
538 esac;;
539 SunOS*)
540 # Some functions have a prototype only with that define, e.g. confstr
541 AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
542 ;;
543 esac
546 AC_SUBST(LIBRARY)
547 AC_MSG_CHECKING(LIBRARY)
548 if test -z "$LIBRARY"
549 then
550 LIBRARY='libpython$(VERSION).a'
551 fi
552 AC_MSG_RESULT($LIBRARY)
554 # LDLIBRARY is the name of the library to link against (as opposed to the
555 # name of the library into which to insert object files). BLDLIBRARY is also
556 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
557 # is blank as the main program is not linked directly against LDLIBRARY.
558 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
559 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
560 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
561 # DLLLIBRARY is the shared (i.e., DLL) library.
562 #
563 # RUNSHARED is used to run shared python without installed libraries
564 #
565 # INSTSONAME is the name of the shared library that will be use to install
566 # on the system - some systems like version suffix, others don't
567 AC_SUBST(LDLIBRARY)
568 AC_SUBST(DLLLIBRARY)
569 AC_SUBST(BLDLIBRARY)
570 AC_SUBST(LDLIBRARYDIR)
571 AC_SUBST(INSTSONAME)
572 AC_SUBST(RUNSHARED)
573 LDLIBRARY="$LIBRARY"
574 BLDLIBRARY='$(LDLIBRARY)'
575 INSTSONAME='$(LDLIBRARY)'
576 DLLLIBRARY=''
577 LDLIBRARYDIR=''
578 RUNSHARED=''
580 # LINKCC is the command that links the python executable -- default is $(CC).
581 # If CXX is set, and if it is needed to link a main function that was
582 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
583 # python might then depend on the C++ runtime
584 # This is altered for AIX in order to build the export list before
585 # linking.
586 AC_SUBST(LINKCC)
587 AC_MSG_CHECKING(LINKCC)
588 if test -z "$LINKCC"
589 then
590 LINKCC='$(PURIFY) $(MAINCC)'
591 case $ac_sys_system in
592 AIX*)
593 exp_extra="\"\""
594 if test $ac_sys_release -ge 5 -o \
595 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
596 exp_extra="."
597 fi
598 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
599 Monterey64*)
600 LINKCC="$LINKCC -L/usr/lib/ia64l64";;
601 QNX*)
602 # qcc must be used because the other compilers do not
603 # support -N.
604 LINKCC=qcc;;
605 esac
606 fi
607 AC_MSG_RESULT($LINKCC)
609 AC_MSG_CHECKING(for --enable-shared)
610 AC_ARG_ENABLE(shared,
611 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
613 if test -z "$enable_shared"
614 then
615 case $ac_sys_system in
616 CYGWIN* | atheos*)
617 enable_shared="yes";;
618 *)
619 enable_shared="no";;
620 esac
621 fi
622 AC_MSG_RESULT($enable_shared)
624 AC_MSG_CHECKING(for --enable-profiling)
625 AC_ARG_ENABLE(profiling,
626 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
627 [ac_save_cc="$CC"
628 CC="$CC -pg"
629 AC_TRY_RUN([int main() { return 0; }],
630 ac_enable_profiling="yes",
631 ac_enable_profiling="no",
632 ac_enable_profiling="no")
633 CC="$ac_save_cc"])
634 AC_MSG_RESULT($ac_enable_profiling)
636 case "$ac_enable_profiling" in
637 "yes")
638 BASECFLAGS="-pg $BASECFLAGS"
639 LDFLAGS="-pg $LDFLAGS"
640 ;;
641 esac
643 AC_MSG_CHECKING(LDLIBRARY)
645 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
646 # library that we build, but we do not want to link against it (we
647 # will find it with a -framework option). For this reason there is an
648 # extra variable BLDLIBRARY against which Python and the extension
649 # modules are linked, BLDLIBRARY. This is normally the same as
650 # LDLIBRARY, but empty for MacOSX framework builds.
651 if test "$enable_framework"
652 then
653 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
654 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
655 BLDLIBRARY=''
656 else
657 BLDLIBRARY='$(LDLIBRARY)'
658 fi
660 # Other platforms follow
661 if test $enable_shared = "yes"; then
662 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
663 case $ac_sys_system in
664 CYGWIN*)
665 LDLIBRARY='libpython$(VERSION).dll.a'
666 DLLLIBRARY='libpython$(VERSION).dll'
667 ;;
668 SunOS*)
669 LDLIBRARY='libpython$(VERSION).so'
670 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
671 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
672 INSTSONAME="$LDLIBRARY".$SOVERSION
673 ;;
674 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
675 LDLIBRARY='libpython$(VERSION).so'
676 BLDLIBRARY='-L. -lpython$(VERSION)'
677 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
678 case $ac_sys_system in
679 FreeBSD*)
680 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
681 ;;
682 esac
683 INSTSONAME="$LDLIBRARY".$SOVERSION
684 ;;
685 hp*|HP*)
686 case `uname -m` in
687 ia64)
688 LDLIBRARY='libpython$(VERSION).so'
689 ;;
690 *)
691 LDLIBRARY='libpython$(VERSION).sl'
692 ;;
693 esac
694 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
695 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
696 ;;
697 OSF*)
698 LDLIBRARY='libpython$(VERSION).so'
699 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
700 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
701 ;;
702 atheos*)
703 LDLIBRARY='libpython$(VERSION).so'
704 BLDLIBRARY='-L. -lpython$(VERSION)'
705 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
706 ;;
707 Darwin*)
708 LDLIBRARY='libpython$(VERSION).dylib'
709 BLDLIBRARY='-L. -lpython$(VERSION)'
710 RUNSHARED='DYLD_LIBRARY_PATH=`pwd`:${DYLD_LIBRARY_PATH}'
711 ;;
713 esac
714 else # shared is disabled
715 case $ac_sys_system in
716 CYGWIN*)
717 BLDLIBRARY='$(LIBRARY)'
718 LDLIBRARY='libpython$(VERSION).dll.a'
719 ;;
720 esac
721 fi
723 AC_MSG_RESULT($LDLIBRARY)
725 AC_PROG_RANLIB
726 AC_SUBST(AR)
727 AC_CHECK_PROGS(AR, ar aal, ar)
729 AC_SUBST(SVNVERSION)
730 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
731 if test $SVNVERSION = found
732 then
733 SVNVERSION="svnversion \$(srcdir)"
734 else
735 SVNVERSION="echo exported"
736 fi
738 case $MACHDEP in
739 bsdos*|hp*|HP*)
740 # install -d does not work on BSDI or HP-UX
741 if test -z "$INSTALL"
742 then
743 INSTALL="${srcdir}/install-sh -c"
744 fi
745 esac
746 AC_PROG_INSTALL
748 # Not every filesystem supports hard links
749 AC_SUBST(LN)
750 if test -z "$LN" ; then
751 case $ac_sys_system in
752 CYGWIN*) LN="ln -s";;
753 atheos*) LN="ln -s";;
754 *) LN=ln;;
755 esac
756 fi
758 # Check for --with-pydebug
759 AC_MSG_CHECKING(for --with-pydebug)
760 AC_ARG_WITH(pydebug,
761 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
762 [
763 if test "$withval" != no
764 then
765 AC_DEFINE(Py_DEBUG, 1,
766 [Define if you want to build an interpreter with many run-time checks.])
767 AC_MSG_RESULT(yes);
768 Py_DEBUG='true'
769 else AC_MSG_RESULT(no); Py_DEBUG='false'
770 fi],
771 [AC_MSG_RESULT(no)])
773 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
774 # merged with this chunk of code?
776 # Optimizer/debugger flags
777 # ------------------------
778 # (The following bit of code is complicated enough - please keep things
779 # indented properly. Just pretend you're editing Python code. ;-)
781 # There are two parallel sets of case statements below, one that checks to
782 # see if OPT was set and one that does BASECFLAGS setting based upon
783 # compiler and platform. BASECFLAGS tweaks need to be made even if the
784 # user set OPT.
786 # tweak OPT based on compiler and platform, only if the user didn't set
787 # it on the command line
788 AC_SUBST(OPT)
789 if test -z "$OPT"
790 then
791 case $GCC in
792 yes)
793 if test "$CC" != 'g++' ; then
794 STRICT_PROTO="-Wstrict-prototypes"
795 fi
796 # For gcc 4.x we need to use -fwrapv so lets check if its supported
797 if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
798 WRAP="-fwrapv"
799 fi
800 case $ac_cv_prog_cc_g in
801 yes)
802 if test "$Py_DEBUG" = 'true' ; then
803 # Optimization messes up debuggers, so turn it off for
804 # debug builds.
805 OPT="-g -Wall $STRICT_PROTO"
806 else
807 OPT="-g $WRAP -O3 -Wall $STRICT_PROTO"
808 fi
809 ;;
810 *)
811 OPT="-O3 -Wall $STRICT_PROTO"
812 ;;
813 esac
814 case $ac_sys_system in
815 SCO_SV*) OPT="$OPT -m486 -DSCO5"
816 ;;
817 esac
818 ;;
820 *)
821 OPT="-O"
822 ;;
823 esac
825 # The current (beta) Monterey compiler dies with optimizations
826 # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
827 case $ac_sys_system in
828 Monterey*)
829 OPT=""
830 ;;
831 esac
833 fi
835 AC_SUBST(BASECFLAGS)
837 # The -arch flags for universal builds on OSX
838 UNIVERSAL_ARCH_FLAGS=
839 AC_SUBST(UNIVERSAL_ARCH_FLAGS)
841 # tweak BASECFLAGS based on compiler and platform
842 case $GCC in
843 yes)
844 # Python violates C99 rules, by casting between incompatible
845 # pointer types. GCC may generate bad code as a result of that,
846 # so use -fno-strict-aliasing if supported.
847 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
848 ac_save_cc="$CC"
849 CC="$CC -fno-strict-aliasing"
850 AC_TRY_RUN([int main() { return 0; }],
851 ac_cv_no_strict_aliasing_ok=yes,
852 ac_cv_no_strict_aliasing_ok=no,
853 ac_cv_no_strict_aliasing_ok=no)
854 CC="$ac_save_cc"
855 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
856 if test $ac_cv_no_strict_aliasing_ok = yes
857 then
858 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
859 fi
861 # if using gcc on alpha, use -mieee to get (near) full IEEE 754
862 # support. Without this, treatment of subnormals doesn't follow
863 # the standard.
864 case $ac_sys_machine in
865 alpha*)
866 BASECFLAGS="$BASECFLAGS -mieee"
867 ;;
868 esac
870 case $ac_sys_system in
871 SCO_SV*)
872 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
873 ;;
874 # is there any other compiler on Darwin besides gcc?
875 Darwin*)
876 # -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
877 # used to be here, but non-Apple gcc doesn't accept them.
880 if test "${enable_universalsdk}"; then
881 UNIVERSAL_ARCH_FLAGS=""
882 if test "$UNIVERSAL_ARCHS" = "32-bit" ; then
883 UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386"
884 ARCH_RUN_32BIT=""
886 elif test "$UNIVERSAL_ARCHS" = "64-bit" ; then
887 UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64"
889 elif test "$UNIVERSAL_ARCHS" = "all" ; then
890 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64"
891 ARCH_RUN_32BIT="arch -i386 -ppc"
893 else
894 AC_MSG_ERROR([proper usage is --with-universalarch=32-bit|64-bit|all])
896 fi
899 BASECFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
900 tgt=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
901 if test "${UNIVERSALSDK}" != "/" -a "${tgt}" '>' '10.4' ; then
902 CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
903 fi
904 fi
906 # Calculate the right deployment target for this build.
907 #
908 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
909 if test ${cur_target} '>' 10.2; then
910 cur_target=10.3
911 fi
912 if test "${UNIVERSAL_ARCHS}" = "all"; then
913 # Ensure that the default platform for a 4-way
914 # universal build is OSX 10.5, that's the first
915 # OS release where 4-way builds make sense.
916 cur_target='10.5'
917 fi
918 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
920 # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
921 # environment with a value that is the same as what we'll use
922 # in the Makefile to ensure that we'll get the same compiler
923 # environment during configure and build time.
924 MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
925 export MACOSX_DEPLOYMENT_TARGET
926 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
928 ;;
929 OSF*)
930 BASECFLAGS="$BASECFLAGS -mieee"
931 ;;
932 esac
933 ;;
935 *)
936 case $ac_sys_system in
937 OpenUNIX*|UnixWare*)
938 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
939 ;;
940 OSF*)
941 BASECFLAGS="$BASECFLAGS -ieee -std"
942 ;;
943 SCO_SV*)
944 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
945 ;;
946 esac
947 ;;
948 esac
950 if test "$Py_DEBUG" = 'true'; then
951 :
952 else
953 OPT="-DNDEBUG $OPT"
954 fi
956 if test "$ac_arch_flags"
957 then
958 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
959 fi
961 # disable check for icc since it seems to pass, but generates a warning
962 if test "$CC" = icc
963 then
964 ac_cv_opt_olimit_ok=no
965 fi
967 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
968 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
969 [ac_save_cc="$CC"
970 CC="$CC -OPT:Olimit=0"
971 AC_TRY_RUN([int main() { return 0; }],
972 ac_cv_opt_olimit_ok=yes,
973 ac_cv_opt_olimit_ok=no,
974 ac_cv_opt_olimit_ok=no)
975 CC="$ac_save_cc"])
976 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
977 if test $ac_cv_opt_olimit_ok = yes; then
978 case $ac_sys_system in
979 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
980 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
981 # environment?
982 Darwin*)
983 ;;
984 *)
985 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
986 ;;
987 esac
988 else
989 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
990 AC_CACHE_VAL(ac_cv_olimit_ok,
991 [ac_save_cc="$CC"
992 CC="$CC -Olimit 1500"
993 AC_TRY_RUN([int main() { return 0; }],
994 ac_cv_olimit_ok=yes,
995 ac_cv_olimit_ok=no,
996 ac_cv_olimit_ok=no)
997 CC="$ac_save_cc"])
998 AC_MSG_RESULT($ac_cv_olimit_ok)
999 if test $ac_cv_olimit_ok = yes; then
1000 BASECFLAGS="$BASECFLAGS -Olimit 1500"
1001 fi
1002 fi
1004 # Check whether GCC supports PyArg_ParseTuple format
1005 if test "$GCC" = "yes"
1006 then
1007 AC_MSG_CHECKING(whether gcc supports ParseTuple __format__)
1008 save_CFLAGS=$CFLAGS
1009 CFLAGS="$CFLAGS -Werror"
1010 AC_TRY_COMPILE([
1011 void f(char*,...)__attribute((format(PyArg_ParseTuple, 1, 2)));
1012 ],,
1013 AC_DEFINE(HAVE_ATTRIBUTE_FORMAT_PARSETUPLE, 1, [Define if GCC supports __attribute__((format(PyArg_ParseTuple, 2, 3)))])
1014 AC_MSG_RESULT(yes),
1015 AC_MSG_RESULT(no)
1016 )
1017 CFLAGS=$save_CFLAGS
1018 fi
1020 # On some compilers, pthreads are available without further options
1021 # (e.g. MacOS X). On some of these systems, the compiler will not
1022 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
1023 # So we have to see first whether pthreads are available without
1024 # options before we can check whether -Kpthread improves anything.
1025 AC_MSG_CHECKING(whether pthreads are available without options)
1026 AC_CACHE_VAL(ac_cv_pthread_is_default,
1027 [AC_TRY_RUN([
1028 #include <pthread.h>
1030 void* routine(void* p){return NULL;}
1032 int main(){
1033 pthread_t p;
1034 if(pthread_create(&p,NULL,routine,NULL)!=0)
1035 return 1;
1036 (void)pthread_detach(p);
1037 return 0;
1038 }
1039 ],
1040 [
1041 ac_cv_pthread_is_default=yes
1042 ac_cv_kthread=no
1043 ac_cv_pthread=no
1044 ],
1045 ac_cv_pthread_is_default=no,
1046 ac_cv_pthread_is_default=no)
1047 ])
1048 AC_MSG_RESULT($ac_cv_pthread_is_default)
1051 if test $ac_cv_pthread_is_default = yes
1052 then
1053 ac_cv_kpthread=no
1054 else
1055 # -Kpthread, if available, provides the right #defines
1056 # and linker options to make pthread_create available
1057 # Some compilers won't report that they do not support -Kpthread,
1058 # so we need to run a program to see whether it really made the
1059 # function available.
1060 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
1061 AC_CACHE_VAL(ac_cv_kpthread,
1062 [ac_save_cc="$CC"
1063 CC="$CC -Kpthread"
1064 AC_TRY_RUN([
1065 #include <pthread.h>
1067 void* routine(void* p){return NULL;}
1069 int main(){
1070 pthread_t p;
1071 if(pthread_create(&p,NULL,routine,NULL)!=0)
1072 return 1;
1073 (void)pthread_detach(p);
1074 return 0;
1075 }
1076 ],
1077 ac_cv_kpthread=yes,
1078 ac_cv_kpthread=no,
1079 ac_cv_kpthread=no)
1080 CC="$ac_save_cc"])
1081 AC_MSG_RESULT($ac_cv_kpthread)
1082 fi
1084 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
1085 then
1086 # -Kthread, if available, provides the right #defines
1087 # and linker options to make pthread_create available
1088 # Some compilers won't report that they do not support -Kthread,
1089 # so we need to run a program to see whether it really made the
1090 # function available.
1091 AC_MSG_CHECKING(whether $CC accepts -Kthread)
1092 AC_CACHE_VAL(ac_cv_kthread,
1093 [ac_save_cc="$CC"
1094 CC="$CC -Kthread"
1095 AC_TRY_RUN([
1096 #include <pthread.h>
1098 void* routine(void* p){return NULL;}
1100 int main(){
1101 pthread_t p;
1102 if(pthread_create(&p,NULL,routine,NULL)!=0)
1103 return 1;
1104 (void)pthread_detach(p);
1105 return 0;
1106 }
1107 ],
1108 ac_cv_kthread=yes,
1109 ac_cv_kthread=no,
1110 ac_cv_kthread=no)
1111 CC="$ac_save_cc"])
1112 AC_MSG_RESULT($ac_cv_kthread)
1113 fi
1115 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
1116 then
1117 # -pthread, if available, provides the right #defines
1118 # and linker options to make pthread_create available
1119 # Some compilers won't report that they do not support -pthread,
1120 # so we need to run a program to see whether it really made the
1121 # function available.
1122 AC_MSG_CHECKING(whether $CC accepts -pthread)
1123 AC_CACHE_VAL(ac_cv_thread,
1124 [ac_save_cc="$CC"
1125 CC="$CC -pthread"
1126 AC_TRY_RUN([
1127 #include <pthread.h>
1129 void* routine(void* p){return NULL;}
1131 int main(){
1132 pthread_t p;
1133 if(pthread_create(&p,NULL,routine,NULL)!=0)
1134 return 1;
1135 (void)pthread_detach(p);
1136 return 0;
1137 }
1138 ],
1139 ac_cv_pthread=yes,
1140 ac_cv_pthread=no,
1141 ac_cv_pthread=no)
1142 CC="$ac_save_cc"])
1143 AC_MSG_RESULT($ac_cv_pthread)
1144 fi
1146 # If we have set a CC compiler flag for thread support then
1147 # check if it works for CXX, too.
1148 ac_cv_cxx_thread=no
1149 if test ! -z "$CXX"
1150 then
1151 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1152 ac_save_cxx="$CXX"
1154 if test "$ac_cv_kpthread" = "yes"
1155 then
1156 CXX="$CXX -Kpthread"
1157 ac_cv_cxx_thread=yes
1158 elif test "$ac_cv_kthread" = "yes"
1159 then
1160 CXX="$CXX -Kthread"
1161 ac_cv_cxx_thread=yes
1162 elif test "$ac_cv_pthread" = "yes"
1163 then
1164 CXX="$CXX -pthread"
1165 ac_cv_cxx_thread=yes
1166 fi
1168 if test $ac_cv_cxx_thread = yes
1169 then
1170 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1171 $CXX -c conftest.$ac_ext 2>&5
1172 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1173 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1174 then
1175 ac_cv_cxx_thread=yes
1176 else
1177 ac_cv_cxx_thread=no
1178 fi
1179 rm -fr conftest*
1180 fi
1181 AC_MSG_RESULT($ac_cv_cxx_thread)
1182 fi
1183 CXX="$ac_save_cxx"
1185 dnl # check for ANSI or K&R ("traditional") preprocessor
1186 dnl AC_MSG_CHECKING(for C preprocessor type)
1187 dnl AC_TRY_COMPILE([
1188 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1189 dnl int foo;
1190 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1191 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1192 dnl AC_MSG_RESULT($cpp_type)
1194 # checks for header files
1195 AC_HEADER_STDC
1196 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1197 fcntl.h grp.h \
1198 ieeefp.h io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
1199 shadow.h signal.h stdint.h stropts.h termios.h thread.h \
1200 unistd.h utime.h \
1201 sys/audioio.h sys/bsdtty.h sys/epoll.h sys/event.h sys/file.h sys/loadavg.h \
1202 sys/lock.h sys/mkdev.h sys/modem.h \
1203 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1204 sys/termio.h sys/time.h \
1205 sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1206 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1207 bluetooth/bluetooth.h linux/tipc.h)
1208 AC_HEADER_DIRENT
1209 AC_HEADER_MAJOR
1211 # On Solaris, term.h requires curses.h
1212 AC_CHECK_HEADERS(term.h,,,[
1213 #ifdef HAVE_CURSES_H
1214 #include <curses.h>
1215 #endif
1216 ])
1218 # On Linux, netlink.h requires asm/types.h
1219 AC_CHECK_HEADERS(linux/netlink.h,,,[
1220 #ifdef HAVE_ASM_TYPES_H
1221 #include <asm/types.h>
1222 #endif
1223 #ifdef HAVE_SYS_SOCKET_H
1224 #include <sys/socket.h>
1225 #endif
1226 ])
1228 # checks for typedefs
1229 was_it_defined=no
1230 AC_MSG_CHECKING(for clock_t in time.h)
1231 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1232 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1233 ])
1234 AC_MSG_RESULT($was_it_defined)
1236 # Check whether using makedev requires defining _OSF_SOURCE
1237 AC_MSG_CHECKING(for makedev)
1238 AC_TRY_LINK([#include <sys/types.h> ],
1239 [ makedev(0, 0) ],
1240 ac_cv_has_makedev=yes,
1241 ac_cv_has_makedev=no)
1242 if test "$ac_cv_has_makedev" = "no"; then
1243 # we didn't link, try if _OSF_SOURCE will allow us to link
1244 AC_TRY_LINK([
1245 #define _OSF_SOURCE 1
1246 #include <sys/types.h>
1247 ],
1248 [ makedev(0, 0) ],
1249 ac_cv_has_makedev=yes,
1250 ac_cv_has_makedev=no)
1251 if test "$ac_cv_has_makedev" = "yes"; then
1252 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1253 fi
1254 fi
1255 AC_MSG_RESULT($ac_cv_has_makedev)
1256 if test "$ac_cv_has_makedev" = "yes"; then
1257 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1258 fi
1260 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1261 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1262 # defined, but the compiler does not support pragma redefine_extname,
1263 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1264 # structures (such as rlimit64) without declaring them. As a
1265 # work-around, disable LFS on such configurations
1267 use_lfs=yes
1268 AC_MSG_CHECKING(Solaris LFS bug)
1269 AC_TRY_COMPILE([
1270 #define _LARGEFILE_SOURCE 1
1271 #define _FILE_OFFSET_BITS 64
1272 #include <sys/resource.h>
1273 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1274 AC_MSG_RESULT($sol_lfs_bug)
1275 if test "$sol_lfs_bug" = "yes"; then
1276 use_lfs=no
1277 fi
1279 if test "$use_lfs" = "yes"; then
1280 # Two defines needed to enable largefile support on various platforms
1281 # These may affect some typedefs
1282 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1283 [This must be defined on some systems to enable large file support.])
1284 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1285 [This must be set to 64 on some systems to enable large file support.])
1286 fi
1288 # Add some code to confdefs.h so that the test for off_t works on SCO
1289 cat >> confdefs.h <<\EOF
1290 #if defined(SCO_DS)
1291 #undef _OFF_T
1292 #endif
1293 EOF
1295 # Type availability checks
1296 AC_TYPE_MODE_T
1297 AC_TYPE_OFF_T
1298 AC_TYPE_PID_T
1299 AC_TYPE_SIGNAL
1300 AC_TYPE_SIZE_T
1301 AC_TYPE_UID_T
1302 AC_TYPE_UINT32_T
1303 AC_TYPE_UINT64_T
1304 AC_TYPE_INT32_T
1305 AC_TYPE_INT64_T
1306 AC_CHECK_TYPE(ssize_t,
1307 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1309 # Sizes of various common basic types
1310 # ANSI C requires sizeof(char) == 1, so no need to check it
1311 AC_CHECK_SIZEOF(int, 4)
1312 AC_CHECK_SIZEOF(long, 4)
1313 AC_CHECK_SIZEOF(void *, 4)
1314 AC_CHECK_SIZEOF(short, 2)
1315 AC_CHECK_SIZEOF(float, 4)
1316 AC_CHECK_SIZEOF(double, 8)
1317 AC_CHECK_SIZEOF(fpos_t, 4)
1318 AC_CHECK_SIZEOF(size_t, 4)
1319 AC_CHECK_SIZEOF(pid_t, 4)
1321 AC_MSG_CHECKING(for long long support)
1322 have_long_long=no
1323 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1324 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1325 have_long_long=yes
1326 ])
1327 AC_MSG_RESULT($have_long_long)
1328 if test "$have_long_long" = yes ; then
1329 AC_CHECK_SIZEOF(long long, 8)
1330 fi
1332 AC_MSG_CHECKING(for long double support)
1333 have_long_double=no
1334 AC_TRY_COMPILE([], [long double x; x = (long double)0;], [
1335 AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define this if you have the type long double.])
1336 have_long_double=yes
1337 ])
1338 AC_MSG_RESULT($have_long_double)
1339 if test "$have_long_double" = yes ; then
1340 AC_CHECK_SIZEOF(long double, 16)
1341 fi
1344 AC_MSG_CHECKING(for _Bool support)
1345 have_c99_bool=no
1346 AC_TRY_COMPILE([], [_Bool x; x = (_Bool)0;], [
1347 AC_DEFINE(HAVE_C99_BOOL, 1, [Define this if you have the type _Bool.])
1348 have_c99_bool=yes
1349 ])
1350 AC_MSG_RESULT($have_c99_bool)
1351 if test "$have_c99_bool" = yes ; then
1352 AC_CHECK_SIZEOF(_Bool, 1)
1353 fi
1355 AC_CHECK_TYPES(uintptr_t,
1356 [AC_CHECK_SIZEOF(uintptr_t, 4)],
1357 [], [#ifdef HAVE_STDINT_H
1358 #include <stdint.h>
1359 #endif])
1362 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1363 AC_MSG_CHECKING(size of off_t)
1364 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1365 [AC_TRY_RUN([#include <stdio.h>
1366 #include <sys/types.h>
1367 main()
1368 {
1369 FILE *f=fopen("conftestval", "w");
1370 if (!f) exit(1);
1371 fprintf(f, "%d\n", sizeof(off_t));
1372 exit(0);
1373 }],
1374 ac_cv_sizeof_off_t=`cat conftestval`,
1375 ac_cv_sizeof_off_t=0,
1376 ac_cv_sizeof_off_t=4)
1377 ])
1378 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1379 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1380 [The number of bytes in an off_t.])
1382 AC_MSG_CHECKING(whether to enable large file support)
1383 if test "$have_long_long" = yes -a \
1384 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1385 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1386 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1387 [Defined to enable large file support when an off_t is bigger than a long
1388 and long long is available and at least as big as an off_t. You may need
1389 to add some flags for configuration and compilation to enable this mode.
1390 (For Solaris and Linux, the necessary defines are already defined.)])
1391 AC_MSG_RESULT(yes)
1392 else
1393 AC_MSG_RESULT(no)
1394 fi
1396 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1397 AC_MSG_CHECKING(size of time_t)
1398 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1399 [AC_TRY_RUN([#include <stdio.h>
1400 #include <time.h>
1401 main()
1402 {
1403 FILE *f=fopen("conftestval", "w");
1404 if (!f) exit(1);
1405 fprintf(f, "%d\n", sizeof(time_t));
1406 exit(0);
1407 }],
1408 ac_cv_sizeof_time_t=`cat conftestval`,
1409 ac_cv_sizeof_time_t=0,
1410 ac_cv_sizeof_time_t=4)
1411 ])
1412 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1413 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1414 [The number of bytes in a time_t.])
1417 # if have pthread_t then define SIZEOF_PTHREAD_T
1418 ac_save_cc="$CC"
1419 if test "$ac_cv_kpthread" = "yes"
1420 then CC="$CC -Kpthread"
1421 elif test "$ac_cv_kthread" = "yes"
1422 then CC="$CC -Kthread"
1423 elif test "$ac_cv_pthread" = "yes"
1424 then CC="$CC -pthread"
1425 fi
1426 AC_MSG_CHECKING(for pthread_t)
1427 have_pthread_t=no
1428 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1429 AC_MSG_RESULT($have_pthread_t)
1430 if test "$have_pthread_t" = yes ; then
1431 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1432 AC_MSG_CHECKING(size of pthread_t)
1433 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1434 [AC_TRY_RUN([#include <stdio.h>
1435 #include <pthread.h>
1436 main()
1437 {
1438 FILE *f=fopen("conftestval", "w");
1439 if (!f) exit(1);
1440 fprintf(f, "%d\n", sizeof(pthread_t));
1441 exit(0);
1442 }],
1443 ac_cv_sizeof_pthread_t=`cat conftestval`,
1444 ac_cv_sizeof_pthread_t=0,
1445 ac_cv_sizeof_pthread_t=4)
1446 ])
1447 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1448 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1449 [The number of bytes in a pthread_t.])
1450 fi
1451 CC="$ac_save_cc"
1455 AC_SUBST(OTHER_LIBTOOL_OPT)
1456 case $ac_sys_system/$ac_sys_release in
1457 Darwin/@<:@01567@:>@\..*)
1458 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1459 ;;
1460 Darwin/*)
1461 OTHER_LIBTOOL_OPT=""
1462 ;;
1463 esac
1465 AC_SUBST(LIBTOOL_CRUFT)
1466 case $ac_sys_system/$ac_sys_release in
1467 Darwin/@<:@01567@:>@\..*)
1468 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1469 if test "${enable_universalsdk}"; then
1470 :
1471 else
1472 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1473 fi
1474 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1475 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1476 Darwin/*)
1477 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1478 if test ${gcc_version} '<' 4.0
1479 then
1480 LIBTOOL_CRUFT="-lcc_dynamic"
1481 else
1482 LIBTOOL_CRUFT=""
1483 fi
1484 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1485 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1486 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1487 esac
1489 AC_MSG_CHECKING(for --enable-framework)
1490 if test "$enable_framework"
1491 then
1492 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1493 # -F. is needed to allow linking to the framework while
1494 # in the build location.
1495 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1496 [Define if you want to produce an OpenStep/Rhapsody framework
1497 (shared library plus accessory files).])
1498 AC_MSG_RESULT(yes)
1499 else
1500 AC_MSG_RESULT(no)
1501 fi
1503 AC_MSG_CHECKING(for dyld)
1504 case $ac_sys_system/$ac_sys_release in
1505 Darwin/*)
1506 AC_DEFINE(WITH_DYLD, 1,
1507 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1508 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1509 linker (rld). Dyld is necessary to support frameworks.])
1510 AC_MSG_RESULT(always on for Darwin)
1511 ;;
1512 *)
1513 AC_MSG_RESULT(no)
1514 ;;
1515 esac
1517 # Set info about shared libraries.
1518 AC_SUBST(SO)
1519 AC_SUBST(LDSHARED)
1520 AC_SUBST(BLDSHARED)
1521 AC_SUBST(CCSHARED)
1522 AC_SUBST(LINKFORSHARED)
1523 # SO is the extension of shared libraries `(including the dot!)
1524 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1525 AC_MSG_CHECKING(SO)
1526 if test -z "$SO"
1527 then
1528 case $ac_sys_system in
1529 hp*|HP*)
1530 case `uname -m` in
1531 ia64) SO=.so;;
1532 *) SO=.sl;;
1533 esac
1534 ;;
1535 CYGWIN*) SO=.dll;;
1536 *) SO=.so;;
1537 esac
1538 else
1539 # this might also be a termcap variable, see #610332
1540 echo
1541 echo '====================================================================='
1542 echo '+ +'
1543 echo '+ WARNING: You have set SO in your environment. +'
1544 echo '+ Do you really mean to change the extension for shared libraries? +'
1545 echo '+ Continuing in 10 seconds to let you to ponder. +'
1546 echo '+ +'
1547 echo '====================================================================='
1548 sleep 10
1549 fi
1550 AC_MSG_RESULT($SO)
1552 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1553 # LDSHARED is the ld *command* used to create shared library
1554 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1555 # (Shared libraries in this instance are shared modules to be loaded into
1556 # Python, as opposed to building Python itself as a shared library.)
1557 AC_MSG_CHECKING(LDSHARED)
1558 if test -z "$LDSHARED"
1559 then
1560 case $ac_sys_system/$ac_sys_release in
1561 AIX*)
1562 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1563 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1564 ;;
1565 IRIX/5*) LDSHARED="ld -shared";;
1566 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1567 SunOS/5*)
1568 if test "$GCC" = "yes"
1569 then LDSHARED='$(CC) -shared'
1570 else LDSHARED='$(CC) -G';
1571 fi ;;
1572 hp*|HP*)
1573 if test "$GCC" = "yes"
1574 then LDSHARED='$(CC) -shared'
1575 else LDSHARED='ld -b';
1576 fi ;;
1577 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1578 Darwin/1.3*)
1579 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1580 if test "$enable_framework" ; then
1581 # Link against the framework. All externals should be defined.
1582 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1583 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1584 else
1585 # No framework. Ignore undefined symbols, assuming they come from Python
1586 LDSHARED="$LDSHARED -undefined suppress"
1587 fi ;;
1588 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1589 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1590 if test "$enable_framework" ; then
1591 # Link against the framework. All externals should be defined.
1592 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1593 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1594 else
1595 # No framework, use the Python app as bundle-loader
1596 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1597 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1598 fi ;;
1599 Darwin/*)
1600 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1601 # This allows an extension to be used in any Python
1603 if test ${MACOSX_DEPLOYMENT_TARGET} '>' 10.2
1604 then
1605 if test "${enable_universalsdk}"; then
1606 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1607 fi
1608 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1609 BLDSHARED="$LDSHARED"
1610 else
1611 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1612 if test "$enable_framework" ; then
1613 # Link against the framework. All externals should be defined.
1614 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1615 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1616 else
1617 # No framework, use the Python app as bundle-loader
1618 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1619 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1620 fi
1621 fi
1622 ;;
1623 Linux*|GNU*|QNX*) LDSHARED='$(CC) -shared';;
1624 BSD/OS*/4*) LDSHARED="gcc -shared";;
1625 FreeBSD*)
1626 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1627 then
1628 LDSHARED="$CC -shared ${LDFLAGS}"
1629 else
1630 LDSHARED="ld -Bshareable ${LDFLAGS}"
1631 fi;;
1632 OpenBSD*)
1633 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1634 then
1635 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1636 else
1637 case `uname -r` in
1638 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1639 LDSHARED="ld -Bshareable ${LDFLAGS}"
1640 ;;
1641 *)
1642 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1643 ;;
1644 esac
1645 fi;;
1646 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1647 OpenUNIX*|UnixWare*)
1648 if test "$GCC" = "yes"
1649 then LDSHARED='$(CC) -shared'
1650 else LDSHARED='$(CC) -G'
1651 fi;;
1652 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1653 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1654 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1655 atheos*) LDSHARED="gcc -shared";;
1656 *) LDSHARED="ld";;
1657 esac
1658 fi
1659 AC_MSG_RESULT($LDSHARED)
1660 BLDSHARED=${BLDSHARED-$LDSHARED}
1661 # CCSHARED are the C *flags* used to create objects to go into a shared
1662 # library (module) -- this is only needed for a few systems
1663 AC_MSG_CHECKING(CCSHARED)
1664 if test -z "$CCSHARED"
1665 then
1666 case $ac_sys_system/$ac_sys_release in
1667 SunOS*) if test "$GCC" = yes;
1668 then CCSHARED="-fPIC";
1669 elif test `uname -p` = sparc;
1670 then CCSHARED="-xcode=pic32";
1671 else CCSHARED="-Kpic";
1672 fi;;
1673 hp*|HP*) if test "$GCC" = yes;
1674 then CCSHARED="-fPIC";
1675 else CCSHARED="+z";
1676 fi;;
1677 Linux*|GNU*) CCSHARED="-fPIC";;
1678 BSD/OS*/4*) CCSHARED="-fpic";;
1679 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1680 OpenUNIX*|UnixWare*)
1681 if test "$GCC" = "yes"
1682 then CCSHARED="-fPIC"
1683 else CCSHARED="-KPIC"
1684 fi;;
1685 SCO_SV*)
1686 if test "$GCC" = "yes"
1687 then CCSHARED="-fPIC"
1688 else CCSHARED="-Kpic -belf"
1689 fi;;
1690 Monterey*) CCSHARED="-G";;
1691 IRIX*/6*) case $CC in
1692 *gcc*) CCSHARED="-shared";;
1693 *) CCSHARED="";;
1694 esac;;
1695 atheos*) CCSHARED="-fPIC";;
1696 esac
1697 fi
1698 AC_MSG_RESULT($CCSHARED)
1699 # LINKFORSHARED are the flags passed to the $(CC) command that links
1700 # the python executable -- this is only needed for a few systems
1701 AC_MSG_CHECKING(LINKFORSHARED)
1702 if test -z "$LINKFORSHARED"
1703 then
1704 case $ac_sys_system/$ac_sys_release in
1705 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1706 hp*|HP*)
1707 LINKFORSHARED="-Wl,-E -Wl,+s";;
1708 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1709 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1710 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1711 # -u libsys_s pulls in all symbols in libsys
1712 Darwin/*)
1713 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1714 # which is
1715 # not used by the core itself but which needs to be in the core so
1716 # that dynamically loaded extension modules have access to it.
1717 # -prebind is no longer used, because it actually seems to give a
1718 # slowdown in stead of a speedup, maybe due to the large number of
1719 # dynamic loads Python does.
1721 LINKFORSHARED="$extra_undefs"
1722 if test "$enable_framework"
1723 then
1724 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1725 fi
1726 LINKFORSHARED="$LINKFORSHARED";;
1727 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1728 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1729 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1730 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1731 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1732 then
1733 LINKFORSHARED="-Wl,--export-dynamic"
1734 fi;;
1735 SunOS/5*) case $CC in
1736 *gcc*)
1737 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1738 then
1739 LINKFORSHARED="-Xlinker --export-dynamic"
1740 fi;;
1741 esac;;
1742 CYGWIN*)
1743 if test $enable_shared = "no"
1744 then
1745 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1746 fi;;
1747 QNX*)
1748 # -Wl,-E causes the symbols to be added to the dynamic
1749 # symbol table so that they can be found when a module
1750 # is loaded. -N 2048K causes the stack size to be set
1751 # to 2048 kilobytes so that the stack doesn't overflow
1752 # when running test_compile.py.
1753 LINKFORSHARED='-Wl,-E -N 2048K';;
1754 esac
1755 fi
1756 AC_MSG_RESULT($LINKFORSHARED)
1759 AC_SUBST(CFLAGSFORSHARED)
1760 AC_MSG_CHECKING(CFLAGSFORSHARED)
1761 if test ! "$LIBRARY" = "$LDLIBRARY"
1762 then
1763 case $ac_sys_system in
1764 CYGWIN*)
1765 # Cygwin needs CCSHARED when building extension DLLs
1766 # but not when building the interpreter DLL.
1767 CFLAGSFORSHARED='';;
1768 *)
1769 CFLAGSFORSHARED='$(CCSHARED)'
1770 esac
1771 fi
1772 AC_MSG_RESULT($CFLAGSFORSHARED)
1774 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1775 # library (with --enable-shared).
1776 # For platforms on which shared libraries are not allowed to have unresolved
1777 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1778 # if it is not required, since it creates a dependency of the shared library
1779 # to LIBS. This, in turn, means that applications linking the shared libpython
1780 # don't need to link LIBS explicitly. The default should be only changed
1781 # on systems where this approach causes problems.
1782 AC_SUBST(SHLIBS)
1783 AC_MSG_CHECKING(SHLIBS)
1784 case "$ac_sys_system" in
1785 *)
1786 SHLIBS='$(LIBS)';;
1787 esac
1788 AC_MSG_RESULT($SHLIBS)
1791 # checks for libraries
1792 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1793 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1795 # only check for sem_init if thread support is requested
1796 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1797 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1798 # posix4 on Solaris 2.6
1799 # pthread (first!) on Linux
1800 fi
1802 # check if we need libintl for locale functions
1803 AC_CHECK_LIB(intl, textdomain,
1804 AC_DEFINE(WITH_LIBINTL, 1,
1805 [Define to 1 if libintl is needed for locale functions.]))
1807 # checks for system dependent C++ extensions support
1808 case "$ac_sys_system" in
1809 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1810 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1811 [loadAndInit("", 0, "")],
1812 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1813 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1814 and you want support for AIX C++ shared extension modules.])
1815 AC_MSG_RESULT(yes)],
1816 [AC_MSG_RESULT(no)]);;
1817 *) ;;
1818 esac
1820 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1821 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1822 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1824 AC_MSG_CHECKING(for --with-libs)
1825 AC_ARG_WITH(libs,
1826 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1827 [
1828 AC_MSG_RESULT($withval)
1829 LIBS="$withval $LIBS"
1830 ],
1831 [AC_MSG_RESULT(no)])
1833 # Check for use of the system libffi library
1834 AC_MSG_CHECKING(for --with-system-ffi)
1835 AC_ARG_WITH(system_ffi,
1836 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1838 AC_MSG_RESULT($with_system_ffi)
1840 # Determine if signalmodule should be used.
1841 AC_SUBST(USE_SIGNAL_MODULE)
1842 AC_SUBST(SIGNAL_OBJS)
1843 AC_MSG_CHECKING(for --with-signal-module)
1844 AC_ARG_WITH(signal-module,
1845 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1847 if test -z "$with_signal_module"
1848 then with_signal_module="yes"
1849 fi
1850 AC_MSG_RESULT($with_signal_module)
1852 if test "${with_signal_module}" = "yes"; then
1853 USE_SIGNAL_MODULE=""
1854 SIGNAL_OBJS=""
1855 else
1856 USE_SIGNAL_MODULE="#"
1857 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1858 fi
1860 # This is used to generate Setup.config
1861 AC_SUBST(USE_THREAD_MODULE)
1862 USE_THREAD_MODULE=""
1864 AC_MSG_CHECKING(for --with-dec-threads)
1865 AC_SUBST(LDLAST)
1866 AC_ARG_WITH(dec-threads,
1867 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1868 [
1869 AC_MSG_RESULT($withval)
1870 LDLAST=-threads
1871 if test "${with_thread+set}" != set; then
1872 with_thread="$withval";
1873 fi],
1874 [AC_MSG_RESULT(no)])
1876 # Templates for things AC_DEFINEd more than once.
1877 # For a single AC_DEFINE, no template is needed.
1878 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1879 AH_TEMPLATE(_REENTRANT,
1880 [Define to force use of thread-safe errno, h_errno, and other functions])
1881 AH_TEMPLATE(WITH_THREAD,
1882 [Define if you want to compile in rudimentary thread support])
1884 AC_MSG_CHECKING(for --with-threads)
1885 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1886 AC_ARG_WITH(threads,
1887 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1889 # --with-thread is deprecated, but check for it anyway
1890 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1891 AC_ARG_WITH(thread,
1892 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1893 [with_threads=$with_thread])
1895 if test -z "$with_threads"
1896 then with_threads="yes"
1897 fi
1898 AC_MSG_RESULT($with_threads)
1900 AC_SUBST(THREADOBJ)
1901 if test "$with_threads" = "no"
1902 then
1903 USE_THREAD_MODULE="#"
1904 elif test "$ac_cv_pthread_is_default" = yes
1905 then
1906 AC_DEFINE(WITH_THREAD)
1907 # Defining _REENTRANT on system with POSIX threads should not hurt.
1908 AC_DEFINE(_REENTRANT)
1909 posix_threads=yes
1910 THREADOBJ="Python/thread.o"
1911 elif test "$ac_cv_kpthread" = "yes"
1912 then
1913 CC="$CC -Kpthread"
1914 if test "$ac_cv_cxx_thread" = "yes"; then
1915 CXX="$CXX -Kpthread"
1916 fi
1917 AC_DEFINE(WITH_THREAD)
1918 posix_threads=yes
1919 THREADOBJ="Python/thread.o"
1920 elif test "$ac_cv_kthread" = "yes"
1921 then
1922 CC="$CC -Kthread"
1923 if test "$ac_cv_cxx_thread" = "yes"; then
1924 CXX="$CXX -Kthread"
1925 fi
1926 AC_DEFINE(WITH_THREAD)
1927 posix_threads=yes
1928 THREADOBJ="Python/thread.o"
1929 elif test "$ac_cv_pthread" = "yes"
1930 then
1931 CC="$CC -pthread"
1932 if test "$ac_cv_cxx_thread" = "yes"; then
1933 CXX="$CXX -pthread"
1934 fi
1935 AC_DEFINE(WITH_THREAD)
1936 posix_threads=yes
1937 THREADOBJ="Python/thread.o"
1938 else
1939 if test ! -z "$with_threads" -a -d "$with_threads"
1940 then LDFLAGS="$LDFLAGS -L$with_threads"
1941 fi
1942 if test ! -z "$withval" -a -d "$withval"
1943 then LDFLAGS="$LDFLAGS -L$withval"
1944 fi
1946 # According to the POSIX spec, a pthreads implementation must
1947 # define _POSIX_THREADS in unistd.h. Some apparently don't
1948 # (e.g. gnu pth with pthread emulation)
1949 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
1950 AC_EGREP_CPP(yes,
1951 [
1952 #include <unistd.h>
1953 #ifdef _POSIX_THREADS
1954 yes
1955 #endif
1956 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
1957 AC_MSG_RESULT($unistd_defines_pthreads)
1959 AC_DEFINE(_REENTRANT)
1960 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
1961 AC_DEFINE(C_THREADS)
1962 AC_DEFINE(HURD_C_THREADS, 1,
1963 [Define if you are using Mach cthreads directly under /include])
1964 LIBS="$LIBS -lthreads"
1965 THREADOBJ="Python/thread.o"],[
1966 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
1967 AC_DEFINE(C_THREADS)
1968 AC_DEFINE(MACH_C_THREADS, 1,
1969 [Define if you are using Mach cthreads under mach /])
1970 THREADOBJ="Python/thread.o"],[
1971 AC_MSG_CHECKING(for --with-pth)
1972 AC_ARG_WITH([pth],
1973 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
1974 [AC_MSG_RESULT($withval)
1975 AC_DEFINE([WITH_THREAD])
1976 AC_DEFINE([HAVE_PTH], 1,
1977 [Define if you have GNU PTH threads.])
1978 LIBS="-lpth $LIBS"
1979 THREADOBJ="Python/thread.o"],
1980 [AC_MSG_RESULT(no)
1982 # Just looking for pthread_create in libpthread is not enough:
1983 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
1984 # So we really have to include pthread.h, and then link.
1985 _libs=$LIBS
1986 LIBS="$LIBS -lpthread"
1987 AC_MSG_CHECKING([for pthread_create in -lpthread])
1988 AC_TRY_LINK([#include <pthread.h>
1990 void * start_routine (void *arg) { exit (0); }], [
1991 pthread_create (NULL, NULL, start_routine, NULL)], [
1992 AC_MSG_RESULT(yes)
1993 AC_DEFINE(WITH_THREAD)
1994 posix_threads=yes
1995 THREADOBJ="Python/thread.o"],[
1996 LIBS=$_libs
1997 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
1998 posix_threads=yes
1999 THREADOBJ="Python/thread.o"],[
2000 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
2001 AC_DEFINE(ATHEOS_THREADS, 1,
2002 [Define this if you have AtheOS threads.])
2003 THREADOBJ="Python/thread.o"],[
2004 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
2005 posix_threads=yes
2006 LIBS="$LIBS -lpthreads"
2007 THREADOBJ="Python/thread.o"], [
2008 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
2009 posix_threads=yes
2010 LIBS="$LIBS -lc_r"
2011 THREADOBJ="Python/thread.o"], [
2012 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
2013 posix_threads=yes
2014 LIBS="$LIBS -lpthread"
2015 THREADOBJ="Python/thread.o"], [
2016 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
2017 posix_threads=yes
2018 LIBS="$LIBS -lcma"
2019 THREADOBJ="Python/thread.o"],[
2020 USE_THREAD_MODULE="#"])
2021 ])])])])])])])])])
2023 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
2024 LIBS="$LIBS -lmpc"
2025 THREADOBJ="Python/thread.o"
2026 USE_THREAD_MODULE=""])
2028 if test "$posix_threads" != "yes"; then
2029 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
2030 LIBS="$LIBS -lthread"
2031 THREADOBJ="Python/thread.o"
2032 USE_THREAD_MODULE=""])
2033 fi
2035 if test "$USE_THREAD_MODULE" != "#"
2036 then
2037 # If the above checks didn't disable threads, (at least) OSF1
2038 # needs this '-threads' argument during linking.
2039 case $ac_sys_system in
2040 OSF1) LDLAST=-threads;;
2041 esac
2042 fi
2043 fi
2045 if test "$posix_threads" = "yes"; then
2046 if test "$unistd_defines_pthreads" = "no"; then
2047 AC_DEFINE(_POSIX_THREADS, 1,
2048 [Define if you have POSIX threads,
2049 and your system does not define that.])
2050 fi
2052 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
2053 case $ac_sys_system/$ac_sys_release in
2054 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
2055 Defined for Solaris 2.6 bug in pthread header.)
2056 ;;
2057 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2058 Define if the Posix semaphores do not work on your system)
2059 ;;
2060 AIX/5) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2061 Define if the Posix semaphores do not work on your system)
2062 ;;
2063 esac
2065 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
2066 AC_CACHE_VAL(ac_cv_pthread_system_supported,
2067 [AC_TRY_RUN([#include <pthread.h>
2068 void *foo(void *parm) {
2069 return NULL;
2070 }
2071 main() {
2072 pthread_attr_t attr;
2073 pthread_t id;
2074 if (pthread_attr_init(&attr)) exit(-1);
2075 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
2076 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
2077 exit(0);
2078 }],
2079 ac_cv_pthread_system_supported=yes,
2080 ac_cv_pthread_system_supported=no,
2081 ac_cv_pthread_system_supported=no)
2082 ])
2083 AC_MSG_RESULT($ac_cv_pthread_system_supported)
2084 if test "$ac_cv_pthread_system_supported" = "yes"; then
2085 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2086 fi
2087 AC_CHECK_FUNCS(pthread_sigmask,
2088 [case $ac_sys_system in
2089 CYGWIN*)
2090 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2091 [Define if pthread_sigmask() does not work on your system.])
2092 ;;
2093 esac])
2094 fi
2097 # Check for enable-ipv6
2098 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2099 AC_MSG_CHECKING([if --enable-ipv6 is specified])
2100 AC_ARG_ENABLE(ipv6,
2101 [ --enable-ipv6 Enable ipv6 (with ipv4) support
2102 --disable-ipv6 Disable ipv6 support],
2103 [ case "$enableval" in
2104 no)
2105 AC_MSG_RESULT(no)
2106 ipv6=no
2107 ;;
2108 *) AC_MSG_RESULT(yes)
2109 AC_DEFINE(ENABLE_IPV6)
2110 ipv6=yes
2111 ;;
2112 esac ],
2114 [
2115 dnl the check does not work on cross compilation case...
2116 AC_TRY_RUN([ /* AF_INET6 available check */
2117 #include <sys/types.h>
2118 #include <sys/socket.h>
2119 main()
2120 {
2121 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2122 exit(1);
2123 else
2124 exit(0);
2125 }
2126 ],
2127 AC_MSG_RESULT(yes)
2128 ipv6=yes,
2129 AC_MSG_RESULT(no)
2130 ipv6=no,
2131 AC_MSG_RESULT(no)
2132 ipv6=no
2133 )
2135 if test "$ipv6" = "yes"; then
2136 AC_MSG_CHECKING(if RFC2553 API is available)
2137 AC_TRY_COMPILE([#include <sys/types.h>
2138 #include <netinet/in.h>],
2139 [struct sockaddr_in6 x;
2140 x.sin6_scope_id;],
2141 AC_MSG_RESULT(yes)
2142 ipv6=yes,
2143 AC_MSG_RESULT(no, IPv6 disabled)
2144 ipv6=no)
2145 fi
2147 if test "$ipv6" = "yes"; then
2148 AC_DEFINE(ENABLE_IPV6)
2149 fi
2150 ])
2152 ipv6type=unknown
2153 ipv6lib=none
2154 ipv6trylibc=no
2156 if test "$ipv6" = "yes"; then
2157 AC_MSG_CHECKING([ipv6 stack type])
2158 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2159 do
2160 case $i in
2161 inria)
2162 dnl http://www.kame.net/
2163 AC_EGREP_CPP(yes, [
2164 #include <netinet/in.h>
2165 #ifdef IPV6_INRIA_VERSION
2166 yes
2167 #endif],
2168 [ipv6type=$i])
2169 ;;
2170 kame)
2171 dnl http://www.kame.net/
2172 AC_EGREP_CPP(yes, [
2173 #include <netinet/in.h>
2174 #ifdef __KAME__
2175 yes
2176 #endif],
2177 [ipv6type=$i;
2178 ipv6lib=inet6
2179 ipv6libdir=/usr/local/v6/lib
2180 ipv6trylibc=yes])
2181 ;;
2182 linux-glibc)
2183 dnl http://www.v6.linux.or.jp/
2184 AC_EGREP_CPP(yes, [
2185 #include <features.h>
2186 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2187 yes
2188 #endif],
2189 [ipv6type=$i;
2190 ipv6trylibc=yes])
2191 ;;
2192 linux-inet6)
2193 dnl http://www.v6.linux.or.jp/
2194 if test -d /usr/inet6; then
2195 ipv6type=$i
2196 ipv6lib=inet6
2197 ipv6libdir=/usr/inet6/lib
2198 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2199 fi
2200 ;;
2201 solaris)
2202 if test -f /etc/netconfig; then
2203 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2204 ipv6type=$i
2205 ipv6trylibc=yes
2206 fi
2207 fi
2208 ;;
2209 toshiba)
2210 AC_EGREP_CPP(yes, [
2211 #include <sys/param.h>
2212 #ifdef _TOSHIBA_INET6
2213 yes
2214 #endif],
2215 [ipv6type=$i;
2216 ipv6lib=inet6;
2217 ipv6libdir=/usr/local/v6/lib])
2218 ;;
2219 v6d)
2220 AC_EGREP_CPP(yes, [
2221 #include </usr/local/v6/include/sys/v6config.h>
2222 #ifdef __V6D__
2223 yes
2224 #endif],
2225 [ipv6type=$i;
2226 ipv6lib=v6;
2227 ipv6libdir=/usr/local/v6/lib;
2228 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2229 ;;
2230 zeta)
2231 AC_EGREP_CPP(yes, [
2232 #include <sys/param.h>
2233 #ifdef _ZETA_MINAMI_INET6
2234 yes
2235 #endif],
2236 [ipv6type=$i;
2237 ipv6lib=inet6;
2238 ipv6libdir=/usr/local/v6/lib])
2239 ;;
2240 esac
2241 if test "$ipv6type" != "unknown"; then
2242 break
2243 fi
2244 done
2245 AC_MSG_RESULT($ipv6type)
2246 fi
2248 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2249 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2250 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2251 echo "using lib$ipv6lib"
2252 else
2253 if test $ipv6trylibc = "yes"; then
2254 echo "using libc"
2255 else
2256 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2257 echo "You need to fetch lib$ipv6lib.a from appropriate"
2258 echo 'ipv6 kit and compile beforehand.'
2259 exit 1
2260 fi
2261 fi
2262 fi
2264 AC_MSG_CHECKING(for OSX 10.5 SDK or later)
2265 AC_TRY_COMPILE([#include <Carbon/Carbon.h>], FSIORefNum fRef = 0,
2266 AC_DEFINE(HAVE_OSX105_SDK, 1, Define if compiling using MacOS X 10.5 SDK or later.)
2267 AC_MSG_RESULT(yes),
2268 AC_MSG_RESULT(no)
2269 )
2271 # Check for --with-doc-strings
2272 AC_MSG_CHECKING(for --with-doc-strings)
2273 AC_ARG_WITH(doc-strings,
2274 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2276 if test -z "$with_doc_strings"
2277 then with_doc_strings="yes"
2278 fi
2279 if test "$with_doc_strings" != "no"
2280 then
2281 AC_DEFINE(WITH_DOC_STRINGS, 1,
2282 [Define if you want documentation strings in extension modules])
2283 fi
2284 AC_MSG_RESULT($with_doc_strings)
2286 # Check for Python-specific malloc support
2287 AC_MSG_CHECKING(for --with-tsc)
2288 AC_ARG_WITH(tsc,
2289 [ --with(out)-tsc enable/disable timestamp counter profile], [
2290 if test "$withval" != no
2291 then
2292 AC_DEFINE(WITH_TSC, 1,
2293 [Define to profile with the Pentium timestamp counter])
2294 AC_MSG_RESULT(yes)
2295 else AC_MSG_RESULT(no)
2296 fi],
2297 [AC_MSG_RESULT(no)])
2299 # Check for Python-specific malloc support
2300 AC_MSG_CHECKING(for --with-pymalloc)
2301 AC_ARG_WITH(pymalloc,
2302 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2304 if test -z "$with_pymalloc"
2305 then with_pymalloc="yes"
2306 fi
2307 if test "$with_pymalloc" != "no"
2308 then
2309 AC_DEFINE(WITH_PYMALLOC, 1,
2310 [Define if you want to compile in Python-specific mallocs])
2311 fi
2312 AC_MSG_RESULT($with_pymalloc)
2314 # Check for --with-wctype-functions
2315 AC_MSG_CHECKING(for --with-wctype-functions)
2316 AC_ARG_WITH(wctype-functions,
2317 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2318 [
2319 if test "$withval" != no
2320 then
2321 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2322 [Define if you want wctype.h functions to be used instead of the
2323 one supplied by Python itself. (see Include/unicodectype.h).])
2324 AC_MSG_RESULT(yes)
2325 else AC_MSG_RESULT(no)
2326 fi],
2327 [AC_MSG_RESULT(no)])
2329 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2330 AC_SUBST(DLINCLDIR)
2331 DLINCLDIR=.
2333 # the dlopen() function means we might want to use dynload_shlib.o. some
2334 # platforms, such as AIX, have dlopen(), but don't want to use it.
2335 AC_CHECK_FUNCS(dlopen)
2337 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2338 # loading of modules.
2339 AC_SUBST(DYNLOADFILE)
2340 AC_MSG_CHECKING(DYNLOADFILE)
2341 if test -z "$DYNLOADFILE"
2342 then
2343 case $ac_sys_system/$ac_sys_release in
2344 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2345 if test "$ac_cv_func_dlopen" = yes
2346 then DYNLOADFILE="dynload_shlib.o"
2347 else DYNLOADFILE="dynload_aix.o"
2348 fi
2349 ;;
2350 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2351 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2352 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2353 atheos*) DYNLOADFILE="dynload_atheos.o";;
2354 *)
2355 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2356 # out any dynamic loading
2357 if test "$ac_cv_func_dlopen" = yes
2358 then DYNLOADFILE="dynload_shlib.o"
2359 else DYNLOADFILE="dynload_stub.o"
2360 fi
2361 ;;
2362 esac
2363 fi
2364 AC_MSG_RESULT($DYNLOADFILE)
2365 if test "$DYNLOADFILE" != "dynload_stub.o"
2366 then
2367 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2368 [Defined when any dynamic module loading is enabled.])
2369 fi
2371 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2373 AC_SUBST(MACHDEP_OBJS)
2374 AC_MSG_CHECKING(MACHDEP_OBJS)
2375 if test -z "$MACHDEP_OBJS"
2376 then
2377 MACHDEP_OBJS=$extra_machdep_objs
2378 else
2379 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2380 fi
2381 AC_MSG_RESULT(MACHDEP_OBJS)
2383 # checks for library functions
2384 AC_CHECK_FUNCS(alarm setitimer getitimer bind_textdomain_codeset chown \
2385 clock confstr ctermid execv fchmod fchown fork fpathconf ftime ftruncate \
2386 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2387 getpriority getpwent getspnam getspent getsid getwd \
2388 kill killpg lchmod lchown lstat mkfifo mknod mktime \
2389 mremap nice pathconf pause plock poll pthread_init \
2390 putenv readlink realpath \
2391 select sem_open sem_timedwait sem_getvalue sem_unlink setegid seteuid \
2392 setgid \
2393 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2394 sigaction siginterrupt sigrelse strftime strlcpy \
2395 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2396 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll wcsxfrm _getpty)
2398 # For some functions, having a definition is not sufficient, since
2399 # we want to take their address.
2400 AC_MSG_CHECKING(for chroot)
2401 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2402 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2403 AC_MSG_RESULT(yes),
2404 AC_MSG_RESULT(no)
2405 )
2406 AC_MSG_CHECKING(for link)
2407 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2408 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2409 AC_MSG_RESULT(yes),
2410 AC_MSG_RESULT(no)
2411 )
2412 AC_MSG_CHECKING(for symlink)
2413 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2414 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2415 AC_MSG_RESULT(yes),
2416 AC_MSG_RESULT(no)
2417 )
2418 AC_MSG_CHECKING(for fchdir)
2419 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2420 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2421 AC_MSG_RESULT(yes),
2422 AC_MSG_RESULT(no)
2423 )
2424 AC_MSG_CHECKING(for fsync)
2425 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2426 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2427 AC_MSG_RESULT(yes),
2428 AC_MSG_RESULT(no)
2429 )
2430 AC_MSG_CHECKING(for fdatasync)
2431 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2432 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2433 AC_MSG_RESULT(yes),
2434 AC_MSG_RESULT(no)
2435 )
2436 AC_MSG_CHECKING(for epoll)
2437 AC_TRY_COMPILE([#include <sys/epoll.h>], void *x=epoll_create,
2438 AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
2439 AC_MSG_RESULT(yes),
2440 AC_MSG_RESULT(no)
2441 )
2442 AC_MSG_CHECKING(for kqueue)
2443 AC_TRY_COMPILE([
2444 #include <sys/types.h>
2445 #include <sys/event.h>
2446 ], int x=kqueue(),
2447 AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
2448 AC_MSG_RESULT(yes),
2449 AC_MSG_RESULT(no)
2450 )
2451 # On some systems (eg. FreeBSD 5), we would find a definition of the
2452 # functions ctermid_r, setgroups in the library, but no prototype
2453 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2454 # address to avoid compiler warnings and potential miscompilations
2455 # because of the missing prototypes.
2457 AC_MSG_CHECKING(for ctermid_r)
2458 AC_TRY_COMPILE([
2459 #include "confdefs.h"
2460 #include <stdio.h>
2461 ], void* p = ctermid_r,
2462 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2463 AC_MSG_RESULT(yes),
2464 AC_MSG_RESULT(no)
2465 )
2467 AC_MSG_CHECKING(for flock)
2468 AC_TRY_COMPILE([
2469 #include "confdefs.h"
2470 #include <sys/file.h>
2471 ], void* p = flock,
2472 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2473 AC_MSG_RESULT(yes),
2474 AC_MSG_RESULT(no)
2475 )
2477 AC_MSG_CHECKING(for getpagesize)
2478 AC_TRY_COMPILE([
2479 #include "confdefs.h"
2480 #include <unistd.h>
2481 ], void* p = getpagesize,
2482 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2483 AC_MSG_RESULT(yes),
2484 AC_MSG_RESULT(no)
2485 )
2487 dnl check for true
2488 AC_CHECK_PROGS(TRUE, true, /bin/true)
2490 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2491 dnl On others, they are in the C library, so we to take no action
2492 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2493 AC_CHECK_LIB(resolv, inet_aton)
2494 )
2496 # On Tru64, chflags seems to be present, but calling it will
2497 # exit Python
2498 AC_MSG_CHECKING(for chflags)
2499 AC_TRY_RUN([
2500 #include <sys/stat.h>
2501 #include <unistd.h>
2502 int main(int argc, char*argv[])
2503 {
2504 if(chflags(argv[0], 0) != 0)
2505 return 1;
2506 return 0;
2507 }
2508 ],AC_DEFINE(HAVE_CHFLAGS, 1, Define to 1 if you have the `chflags' function.)
2509 AC_MSG_RESULT(yes),
2510 AC_MSG_RESULT(no)
2511 )
2513 AC_MSG_CHECKING(for lchflags)
2514 AC_TRY_RUN([
2515 #include <sys/stat.h>
2516 #include <unistd.h>
2517 int main(int argc, char*argv[])
2518 {
2519 if(lchflags(argv[0], 0) != 0)
2520 return 1;
2521 return 0;
2522 }
2523 ],AC_DEFINE(HAVE_LCHFLAGS, 1, Define to 1 if you have the `lchflags' function.)
2524 AC_MSG_RESULT(yes),
2525 AC_MSG_RESULT(no)
2526 )
2528 dnl Check if system zlib has *Copy() functions
2529 dnl
2530 dnl On MacOSX the linker will search for dylibs on the entire linker path
2531 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2532 dnl to revert to a more traditional unix behaviour and make it possible to
2533 dnl override the system libz with a local static library of libz. Temporarily
2534 dnl add that flag to our CFLAGS as well to ensure that we check the version
2535 dnl of libz that will be used by setup.py.
2536 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2537 dnl environment as setup.py (and leaving it out can cause configure to use the
2538 dnl wrong version of the library)
2539 case $ac_sys_system/$ac_sys_release in
2540 Darwin/*)
2541 _CUR_CFLAGS="${CFLAGS}"
2542 _CUR_LDFLAGS="${LDFLAGS}"
2543 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2544 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2545 ;;
2546 esac
2548 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2550 case $ac_sys_system/$ac_sys_release in
2551 Darwin/*)
2552 CFLAGS="${_CUR_CFLAGS}"
2553 LDFLAGS="${_CUR_LDFLAGS}"
2554 ;;
2555 esac
2557 AC_MSG_CHECKING(for hstrerror)
2558 AC_TRY_LINK([
2559 #include "confdefs.h"
2560 #include <netdb.h>
2561 ], void* p = hstrerror; hstrerror(0),
2562 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2563 AC_MSG_RESULT(yes),
2564 AC_MSG_RESULT(no)
2565 )
2567 AC_MSG_CHECKING(for inet_aton)
2568 AC_TRY_LINK([
2569 #include "confdefs.h"
2570 #include <sys/types.h>
2571 #include <sys/socket.h>
2572 #include <netinet/in.h>
2573 #include <arpa/inet.h>
2574 ], void* p = inet_aton;inet_aton(0,0),
2575 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2576 AC_MSG_RESULT(yes),
2577 AC_MSG_RESULT(no)
2578 )
2580 AC_MSG_CHECKING(for inet_pton)
2581 AC_TRY_COMPILE([
2582 #include "confdefs.h"
2583 #include <sys/types.h>
2584 #include <sys/socket.h>
2585 #include <netinet/in.h>
2586 #include <arpa/inet.h>
2587 ], void* p = inet_pton,
2588 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2589 AC_MSG_RESULT(yes),
2590 AC_MSG_RESULT(no)
2591 )
2593 # On some systems, setgroups is in unistd.h, on others, in grp.h
2594 AC_MSG_CHECKING(for setgroups)
2595 AC_TRY_COMPILE([
2596 #include "confdefs.h"
2597 #include <unistd.h>
2598 #ifdef HAVE_GRP_H
2599 #include <grp.h>
2600 #endif
2601 ],
2602 void* p = setgroups,
2603 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2604 AC_MSG_RESULT(yes),
2605 AC_MSG_RESULT(no)
2606 )
2608 # check for openpty and forkpty
2610 AC_CHECK_FUNCS(openpty,,
2611 AC_CHECK_LIB(util,openpty,
2612 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2613 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2614 )
2615 )
2616 AC_CHECK_FUNCS(forkpty,,
2617 AC_CHECK_LIB(util,forkpty,
2618 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2619 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2620 )
2621 )
2623 # Stuff for expat.
2624 AC_CHECK_FUNCS(memmove)
2626 # check for long file support functions
2627 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2629 AC_REPLACE_FUNCS(dup2 getcwd strdup)
2630 AC_CHECK_FUNCS(getpgrp,
2631 AC_TRY_COMPILE([#include <unistd.h>],
2632 [getpgrp(0);],
2633 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2634 [Define if getpgrp() must be called as getpgrp(0).])
2635 )
2636 )
2637 AC_CHECK_FUNCS(setpgrp,
2638 AC_TRY_COMPILE([#include <unistd.h>],
2639 [setpgrp(0,0);],
2640 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2641 [Define if setpgrp() must be called as setpgrp(0, 0).])
2642 )
2643 )
2644 AC_CHECK_FUNCS(gettimeofday,
2645 AC_TRY_COMPILE([#include <sys/time.h>],
2646 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2647 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2648 [Define if gettimeofday() does not have second (timezone) argument
2649 This is the case on Motorola V4 (R40V4.2)])
2650 )
2651 )
2653 AC_MSG_CHECKING(for major, minor, and makedev)
2654 AC_TRY_LINK([
2655 #if defined(MAJOR_IN_MKDEV)
2656 #include <sys/mkdev.h>
2657 #elif defined(MAJOR_IN_SYSMACROS)
2658 #include <sys/sysmacros.h>
2659 #else
2660 #include <sys/types.h>
2661 #endif
2662 ],[
2663 makedev(major(0),minor(0));
2664 ],[
2665 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2666 [Define to 1 if you have the device macros.])
2667 AC_MSG_RESULT(yes)
2668 ],[
2669 AC_MSG_RESULT(no)
2670 ])
2672 # On OSF/1 V5.1, getaddrinfo is available, but a define
2673 # for [no]getaddrinfo in netdb.h.
2674 AC_MSG_CHECKING(for getaddrinfo)
2675 AC_TRY_LINK([
2676 #include <sys/types.h>
2677 #include <sys/socket.h>
2678 #include <netdb.h>
2679 #include <stdio.h>
2680 ],[
2681 getaddrinfo(NULL, NULL, NULL, NULL);
2682 ], [
2683 AC_MSG_RESULT(yes)
2684 AC_MSG_CHECKING(getaddrinfo bug)
2685 AC_TRY_RUN([
2686 #include <sys/types.h>
2687 #include <netdb.h>
2688 #include <string.h>
2689 #include <sys/socket.h>
2690 #include <netinet/in.h>
2692 main()
2693 {
2694 int passive, gaierr, inet4 = 0, inet6 = 0;
2695 struct addrinfo hints, *ai, *aitop;
2696 char straddr[INET6_ADDRSTRLEN], strport[16];
2698 for (passive = 0; passive <= 1; passive++) {
2699 memset(&hints, 0, sizeof(hints));
2700 hints.ai_family = AF_UNSPEC;
2701 hints.ai_flags = passive ? AI_PASSIVE : 0;
2702 hints.ai_socktype = SOCK_STREAM;
2703 hints.ai_protocol = IPPROTO_TCP;
2704 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2705 (void)gai_strerror(gaierr);
2706 goto bad;
2707 }
2708 for (ai = aitop; ai; ai = ai->ai_next) {
2709 if (ai->ai_addr == NULL ||
2710 ai->ai_addrlen == 0 ||
2711 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2712 straddr, sizeof(straddr), strport, sizeof(strport),
2713 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2714 goto bad;
2715 }
2716 switch (ai->ai_family) {
2717 case AF_INET:
2718 if (strcmp(strport, "54321") != 0) {
2719 goto bad;
2720 }
2721 if (passive) {
2722 if (strcmp(straddr, "0.0.0.0") != 0) {
2723 goto bad;
2724 }
2725 } else {
2726 if (strcmp(straddr, "127.0.0.1") != 0) {
2727 goto bad;
2728 }
2729 }
2730 inet4++;
2731 break;
2732 case AF_INET6:
2733 if (strcmp(strport, "54321") != 0) {
2734 goto bad;
2735 }
2736 if (passive) {
2737 if (strcmp(straddr, "::") != 0) {
2738 goto bad;
2739 }
2740 } else {
2741 if (strcmp(straddr, "::1") != 0) {
2742 goto bad;
2743 }
2744 }
2745 inet6++;
2746 break;
2747 case AF_UNSPEC:
2748 goto bad;
2749 break;
2750 default:
2751 /* another family support? */
2752 break;
2753 }
2754 }
2755 }
2757 if (!(inet4 == 0 || inet4 == 2))
2758 goto bad;
2759 if (!(inet6 == 0 || inet6 == 2))
2760 goto bad;
2762 if (aitop)
2763 freeaddrinfo(aitop);
2764 exit(0);
2766 bad:
2767 if (aitop)
2768 freeaddrinfo(aitop);
2769 exit(1);
2770 }
2771 ],
2772 AC_MSG_RESULT(good)
2773 buggygetaddrinfo=no,
2774 AC_MSG_RESULT(buggy)
2775 buggygetaddrinfo=yes,
2776 AC_MSG_RESULT(buggy)
2777 buggygetaddrinfo=yes)], [
2778 AC_MSG_RESULT(no)
2779 buggygetaddrinfo=yes
2780 ])
2782 if test "$buggygetaddrinfo" = "yes"; then
2783 if test "$ipv6" = "yes"; then
2784 echo 'Fatal: You must get working getaddrinfo() function.'
2785 echo ' or you can specify "--disable-ipv6"'.
2786 exit 1
2787 fi
2788 else
2789 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2790 fi
2791 AC_CHECK_FUNCS(getnameinfo)
2793 # checks for structures
2794 AC_HEADER_TIME
2795 AC_STRUCT_TM
2796 AC_STRUCT_TIMEZONE
2797 AC_CHECK_MEMBERS([struct stat.st_rdev])
2798 AC_CHECK_MEMBERS([struct stat.st_blksize])
2799 AC_CHECK_MEMBERS([struct stat.st_flags])
2800 AC_CHECK_MEMBERS([struct stat.st_gen])
2801 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2802 AC_STRUCT_ST_BLOCKS
2804 AC_MSG_CHECKING(for time.h that defines altzone)
2805 AC_CACHE_VAL(ac_cv_header_time_altzone,
2806 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2807 ac_cv_header_time_altzone=yes,
2808 ac_cv_header_time_altzone=no)])
2809 AC_MSG_RESULT($ac_cv_header_time_altzone)
2810 if test $ac_cv_header_time_altzone = yes; then
2811 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2812 fi
2814 was_it_defined=no
2815 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2816 AC_TRY_COMPILE([
2817 #include <sys/types.h>
2818 #include <sys/select.h>
2819 #include <sys/time.h>
2820 ], [;], [
2821 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2822 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2823 (which you can't on SCO ODT 3.0).])
2824 was_it_defined=yes
2825 ])
2826 AC_MSG_RESULT($was_it_defined)
2828 AC_MSG_CHECKING(for addrinfo)
2829 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2830 AC_TRY_COMPILE([
2831 # include <netdb.h>],
2832 [struct addrinfo a],
2833 ac_cv_struct_addrinfo=yes,
2834 ac_cv_struct_addrinfo=no))
2835 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2836 if test $ac_cv_struct_addrinfo = yes; then
2837 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2838 fi
2840 AC_MSG_CHECKING(for sockaddr_storage)
2841 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2842 AC_TRY_COMPILE([
2843 # include <sys/types.h>
2844 # include <sys/socket.h>],
2845 [struct sockaddr_storage s],
2846 ac_cv_struct_sockaddr_storage=yes,
2847 ac_cv_struct_sockaddr_storage=no))
2848 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2849 if test $ac_cv_struct_sockaddr_storage = yes; then
2850 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2851 fi
2853 # checks for compiler characteristics
2855 AC_C_CHAR_UNSIGNED
2856 AC_C_CONST
2858 works=no
2859 AC_MSG_CHECKING(for working volatile)
2860 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2861 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2862 )
2863 AC_MSG_RESULT($works)
2865 works=no
2866 AC_MSG_CHECKING(for working signed char)
2867 AC_TRY_COMPILE([], [signed char c;], works=yes,
2868 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2869 )
2870 AC_MSG_RESULT($works)
2872 have_prototypes=no
2873 AC_MSG_CHECKING(for prototypes)
2874 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2875 AC_DEFINE(HAVE_PROTOTYPES, 1,
2876 [Define if your compiler supports function prototype])
2877 have_prototypes=yes
2878 ])
2879 AC_MSG_RESULT($have_prototypes)
2881 works=no
2882 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2883 AC_TRY_COMPILE([
2884 #include <stdarg.h>
2885 int foo(int x, ...) {
2886 va_list va;
2887 va_start(va, x);
2888 va_arg(va, int);
2889 va_arg(va, char *);
2890 va_arg(va, double);
2891 return 0;
2892 }
2893 ], [return foo(10, "", 3.14);], [
2894 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2895 [Define if your compiler supports variable length function prototypes
2896 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2897 works=yes
2898 ])
2899 AC_MSG_RESULT($works)
2901 # check for socketpair
2902 AC_MSG_CHECKING(for socketpair)
2903 AC_TRY_COMPILE([
2904 #include <sys/types.h>
2905 #include <sys/socket.h>
2906 ], void *x=socketpair,
2907 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2908 AC_MSG_RESULT(yes),
2909 AC_MSG_RESULT(no)
2910 )
2912 # check if sockaddr has sa_len member
2913 AC_MSG_CHECKING(if sockaddr has sa_len member)
2914 AC_TRY_COMPILE([#include <sys/types.h>
2915 #include <sys/socket.h>],
2916 [struct sockaddr x;
2917 x.sa_len = 0;],
2918 AC_MSG_RESULT(yes)
2919 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2920 AC_MSG_RESULT(no))
2922 va_list_is_array=no
2923 AC_MSG_CHECKING(whether va_list is an array)
2924 AC_TRY_COMPILE([
2925 #ifdef HAVE_STDARG_PROTOTYPES
2926 #include <stdarg.h>
2927 #else
2928 #include <varargs.h>
2929 #endif
2930 ], [va_list list1, list2; list1 = list2;], , [
2931 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2932 va_list_is_array=yes
2933 ])
2934 AC_MSG_RESULT($va_list_is_array)
2936 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2937 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2938 [Define this if you have some version of gethostbyname_r()])
2940 AC_CHECK_FUNC(gethostbyname_r, [
2941 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2942 AC_MSG_CHECKING([gethostbyname_r with 6 args])
2943 OLD_CFLAGS=$CFLAGS
2944 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2945 AC_TRY_COMPILE([
2946 # include <netdb.h>
2947 ], [
2948 char *name;
2949 struct hostent *he, *res;
2950 char buffer[2048];
2951 int buflen = 2048;
2952 int h_errnop;
2954 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2955 ], [
2956 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2957 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
2958 [Define this if you have the 6-arg version of gethostbyname_r().])
2959 AC_MSG_RESULT(yes)
2960 ], [
2961 AC_MSG_RESULT(no)
2962 AC_MSG_CHECKING([gethostbyname_r with 5 args])
2963 AC_TRY_COMPILE([
2964 # include <netdb.h>
2965 ], [
2966 char *name;
2967 struct hostent *he;
2968 char buffer[2048];
2969 int buflen = 2048;
2970 int h_errnop;
2972 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2973 ], [
2974 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2975 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
2976 [Define this if you have the 5-arg version of gethostbyname_r().])
2977 AC_MSG_RESULT(yes)
2978 ], [
2979 AC_MSG_RESULT(no)
2980 AC_MSG_CHECKING([gethostbyname_r with 3 args])
2981 AC_TRY_COMPILE([
2982 # include <netdb.h>
2983 ], [
2984 char *name;
2985 struct hostent *he;
2986 struct hostent_data data;
2988 (void) gethostbyname_r(name, he, &data);
2989 ], [
2990 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2991 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
2992 [Define this if you have the 3-arg version of gethostbyname_r().])
2993 AC_MSG_RESULT(yes)
2994 ], [
2995 AC_MSG_RESULT(no)
2996 ])
2997 ])
2998 ])
2999 CFLAGS=$OLD_CFLAGS
3000 ], [
3001 AC_CHECK_FUNCS(gethostbyname)
3002 ])
3003 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
3004 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
3005 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
3006 AC_SUBST(HAVE_GETHOSTBYNAME_R)
3007 AC_SUBST(HAVE_GETHOSTBYNAME)
3009 # checks for system services
3010 # (none yet)
3012 # Linux requires this for correct f.p. operations
3013 AC_CHECK_FUNC(__fpu_control,
3014 [],
3015 [AC_CHECK_LIB(ieee, __fpu_control)
3016 ])
3018 # Check for --with-fpectl
3019 AC_MSG_CHECKING(for --with-fpectl)
3020 AC_ARG_WITH(fpectl,
3021 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
3022 [
3023 if test "$withval" != no
3024 then
3025 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
3026 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
3027 AC_MSG_RESULT(yes)
3028 else AC_MSG_RESULT(no)
3029 fi],
3030 [AC_MSG_RESULT(no)])
3032 # check for --with-libm=...
3033 AC_SUBST(LIBM)
3034 case $ac_sys_system in
3035 Darwin) ;;
3036 *) LIBM=-lm
3037 esac
3038 AC_MSG_CHECKING(for --with-libm=STRING)
3039 AC_ARG_WITH(libm,
3040 AC_HELP_STRING(--with-libm=STRING, math library),
3041 [
3042 if test "$withval" = no
3043 then LIBM=
3044 AC_MSG_RESULT(force LIBM empty)
3045 elif test "$withval" != yes
3046 then LIBM=$withval
3047 AC_MSG_RESULT(set LIBM="$withval")
3048 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
3049 fi],
3050 [AC_MSG_RESULT(default LIBM="$LIBM")])
3052 # check for --with-libc=...
3053 AC_SUBST(LIBC)
3054 AC_MSG_CHECKING(for --with-libc=STRING)
3055 AC_ARG_WITH(libc,
3056 AC_HELP_STRING(--with-libc=STRING, C library),
3057 [
3058 if test "$withval" = no
3059 then LIBC=
3060 AC_MSG_RESULT(force LIBC empty)
3061 elif test "$withval" != yes
3062 then LIBC=$withval
3063 AC_MSG_RESULT(set LIBC="$withval")
3064 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
3065 fi],
3066 [AC_MSG_RESULT(default LIBC="$LIBC")])
3068 # ************************************
3069 # * Check for mathematical functions *
3070 # ************************************
3072 LIBS_SAVE=$LIBS
3073 LIBS="$LIBS $LIBM"
3075 # Detect whether system arithmetic is subject to x87-style double
3076 # rounding issues. The result of this test has little meaning on non
3077 # IEEE 754 platforms. On IEEE 754, test should return 1 if rounding
3078 # mode is round-to-nearest and double rounding issues are present, and
3079 # 0 otherwise. See http://bugs.python.org/issue2937 for more info.
3080 AC_MSG_CHECKING(for x87-style double rounding)
3081 AC_CACHE_VAL(ac_cv_x87_double_rounding, [
3082 AC_TRY_RUN([
3083 #include <stdlib.h>
3084 #include <math.h>
3085 int main() {
3086 volatile double x, y, z;
3087 /* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */
3088 x = 0.99999999999999989; /* 1-2**-53 */
3089 y = 1./x;
3090 if (y != 1.)
3091 exit(0);
3092 /* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
3093 x = 1e16;
3094 y = 2.99999;
3095 z = x + y;
3096 if (z != 1e16+4.)
3097 exit(0);
3098 /* both tests show evidence of double rounding */
3099 exit(1);
3100 }
3101 ],
3102 ac_cv_x87_double_rounding=no,
3103 ac_cv_x87_double_rounding=yes,
3104 ac_cv_x87_double_rounding=no)])
3105 AC_MSG_RESULT($ac_cv_x87_double_rounding)
3106 if test "$ac_cv_x87_double_rounding" = yes
3107 then
3108 AC_DEFINE(X87_DOUBLE_ROUNDING, 1,
3109 [Define if arithmetic is subject to x87-style double rounding issue])
3110 fi
3112 # Multiprocessing check for broken sem_getvalue
3113 AC_MSG_CHECKING(for broken sem_getvalue)
3114 AC_TRY_RUN([
3115 #include <unistd.h>
3116 #include <fcntl.h>
3117 #include <stdio.h>
3118 #include <semaphore.h>
3119 #include <sys/stat.h>
3121 int main(void){
3122 sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR|S_IWUSR, 0);
3123 int count;
3124 int res;
3125 if(a==SEM_FAILED){
3126 perror("sem_open");
3127 return 1;
3129 }
3130 res = sem_getvalue(a, &count);
3131 sem_close(a);
3132 return res==-1 ? 1 : 0;
3133 }
3134 ]
3135 ,AC_MSG_RESULT(no),
3136 AC_MSG_RESULT(yes)
3137 AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1, define to 1 if your sem_getvalue is broken.)
3138 )
3140 # On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
3141 # -0. on some architectures.
3142 AC_MSG_CHECKING(whether tanh preserves the sign of zero)
3143 AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
3144 AC_TRY_RUN([
3145 #include <math.h>
3146 #include <stdlib.h>
3147 int main() {
3148 /* return 0 if either negative zeros don't exist
3149 on this platform or if negative zeros exist
3150 and tanh(-0.) == -0. */
3151 if (atan2(0., -1.) == atan2(-0., -1.) ||
3152 atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
3153 else exit(1);
3154 }
3155 ],
3156 ac_cv_tanh_preserves_zero_sign=yes,
3157 ac_cv_tanh_preserves_zero_sign=no,
3158 ac_cv_tanh_preserves_zero_sign=no)])
3159 AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
3160 if test "$ac_cv_tanh_preserves_zero_sign" = yes
3161 then
3162 AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
3163 [Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
3164 fi
3166 AC_CHECK_FUNCS([acosh asinh atanh copysign expm1 finite hypot log1p])
3167 AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]])
3169 LIBS=$LIBS_SAVE
3171 # determine what size digit to use for Python's longs
3172 AC_MSG_CHECKING([digit size for Python's longs])
3173 AC_ARG_ENABLE(big-digits,
3174 AC_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
3175 [case $enable_big_digits in
3176 yes)
3177 enable_big_digits=30 ;;
3178 no)
3179 enable_big_digits=15 ;;
3180 [15|30])
3181 ;;
3182 *)
3183 AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
3184 esac
3185 AC_MSG_RESULT($enable_big_digits)
3186 AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits])
3187 ],
3188 [AC_MSG_RESULT(no value specified)])
3190 # check for wchar.h
3191 AC_CHECK_HEADER(wchar.h, [
3192 AC_DEFINE(HAVE_WCHAR_H, 1,
3193 [Define if the compiler provides a wchar.h header file.])
3194 wchar_h="yes"
3195 ],
3196 wchar_h="no"
3197 )
3199 # determine wchar_t size
3200 if test "$wchar_h" = yes
3201 then
3202 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
3203 fi
3205 AC_MSG_CHECKING(for UCS-4 tcl)
3206 have_ucs4_tcl=no
3207 AC_TRY_COMPILE([
3208 #include <tcl.h>
3209 #if TCL_UTF_MAX != 6
3210 # error "NOT UCS4_TCL"
3211 #endif], [], [
3212 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
3213 have_ucs4_tcl=yes
3214 ])
3215 AC_MSG_RESULT($have_ucs4_tcl)
3217 # check whether wchar_t is signed or not
3218 if test "$wchar_h" = yes
3219 then
3220 # check whether wchar_t is signed or not
3221 AC_MSG_CHECKING(whether wchar_t is signed)
3222 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
3223 AC_TRY_RUN([
3224 #include <wchar.h>
3225 int main()
3226 {
3227 /* Success: exit code 0 */
3228 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
3229 }
3230 ],
3231 ac_cv_wchar_t_signed=yes,
3232 ac_cv_wchar_t_signed=no,
3233 ac_cv_wchar_t_signed=yes)])
3234 AC_MSG_RESULT($ac_cv_wchar_t_signed)
3235 fi
3237 AC_MSG_CHECKING(what type to use for str)
3238 AC_ARG_WITH(wide-unicode,
3239 AC_HELP_STRING(--with-wide-unicode, Use 4-byte Unicode characters (default is 2 bytes)),
3240 [
3241 if test "$withval" != no
3242 then unicode_size="4"
3243 else unicode_size="2"
3244 fi
3245 ],
3246 [
3247 case "$have_ucs4_tcl" in
3248 yes) unicode_size="4" ;;
3249 *) unicode_size="2" ;;
3250 esac
3251 ])
3253 AH_TEMPLATE(Py_UNICODE_SIZE,
3254 [Define as the size of the unicode type.])
3255 case "$unicode_size" in
3256 4) AC_DEFINE(Py_UNICODE_SIZE, 4) ;;
3257 *) AC_DEFINE(Py_UNICODE_SIZE, 2) ;;
3258 esac
3260 AH_TEMPLATE(PY_UNICODE_TYPE,
3261 [Define as the integral type used for Unicode representation.])
3263 # wchar_t is only usable if it maps to an unsigned type
3264 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3265 -a "$ac_cv_wchar_t_signed" = "no"
3266 then
3267 PY_UNICODE_TYPE="wchar_t"
3268 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3269 [Define if you have a useable wchar_t type defined in wchar.h; useable
3270 means wchar_t must be an unsigned type with at least 16 bits. (see
3271 Include/unicodeobject.h).])
3272 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3273 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3274 then
3275 PY_UNICODE_TYPE="unsigned short"
3276 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3277 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3278 then
3279 PY_UNICODE_TYPE="unsigned long"
3280 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3281 else
3282 PY_UNICODE_TYPE="no type found"
3283 fi
3284 AC_MSG_RESULT($PY_UNICODE_TYPE)
3286 # check for endianness
3287 AC_C_BIGENDIAN
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, [
3293 AC_TRY_RUN([
3294 int main()
3295 {
3296 exit(((-1)>>3 == -1) ? 0 : 1);
3297 }
3298 ],
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
3304 then
3305 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3306 [Define if i>>j for signed int i does not extend the sign bit
3307 when i < 0])
3308 fi
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");
3315 flockfile(f);
3316 getc_unlocked(f);
3317 funlockfile(f);
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
3321 then
3322 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3323 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3324 fi
3326 # check where readline lives
3327 # save the value of LIBS so we don't actually link Python with readline
3328 LIBS_no_readline=$LIBS
3330 # On some systems we need to link readline to a termcap compatible
3331 # library. NOTE: Keep the precedence of listed libraries synchronised
3332 # with setup.py.
3333 py_cv_lib_readline=no
3334 AC_MSG_CHECKING([how to link readline libs])
3335 for py_libtermcap in "" ncursesw ncurses curses termcap; do
3336 if test -z "$py_libtermcap"; then
3337 READLINE_LIBS="-lreadline"
3338 else
3339 READLINE_LIBS="-lreadline -l$py_libtermcap"
3340 fi
3341 LIBS="$READLINE_LIBS $LIBS_no_readline"
3342 AC_LINK_IFELSE(
3343 [AC_LANG_CALL([],[readline])],
3344 [py_cv_lib_readline=yes])
3345 if test $py_cv_lib_readline = yes; then
3346 break
3347 fi
3348 done
3349 # Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
3350 #AC_SUBST([READLINE_LIBS])
3351 if test $py_cv_lib_readline = no; then
3352 AC_MSG_RESULT([none])
3353 else
3354 AC_MSG_RESULT([$READLINE_LIBS])
3355 AC_DEFINE(HAVE_LIBREADLINE, 1,
3356 [Define if you have the readline library (-lreadline).])
3357 fi
3359 # check for readline 2.1
3360 AC_CHECK_LIB(readline, rl_callback_handler_install,
3361 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3362 [Define if you have readline 2.1]), ,$READLINE_LIBS)
3364 # check for readline 2.2
3365 AC_TRY_CPP([#include <readline/readline.h>],
3366 have_readline=yes, have_readline=no)
3367 if test $have_readline = yes
3368 then
3369 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3370 [readline/readline.h],
3371 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3372 [Define if you have readline 2.2]), )
3373 fi
3375 # check for readline 4.0
3376 AC_CHECK_LIB(readline, rl_pre_input_hook,
3377 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3378 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3380 # also in 4.0
3381 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
3382 AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
3383 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3385 # check for readline 4.2
3386 AC_CHECK_LIB(readline, rl_completion_matches,
3387 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3388 [Define if you have readline 4.2]), ,$READLINE_LIBS)
3390 # also in readline 4.2
3391 AC_TRY_CPP([#include <readline/readline.h>],
3392 have_readline=yes, have_readline=no)
3393 if test $have_readline = yes
3394 then
3395 AC_EGREP_HEADER([extern int rl_catch_signals;],
3396 [readline/readline.h],
3397 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3398 [Define if you can turn off readline's signal handling.]), )
3399 fi
3401 # End of readline checks: restore LIBS
3402 LIBS=$LIBS_no_readline
3404 AC_MSG_CHECKING(for broken nice())
3405 AC_CACHE_VAL(ac_cv_broken_nice, [
3406 AC_TRY_RUN([
3407 int main()
3408 {
3409 int val1 = nice(1);
3410 if (val1 != -1 && val1 == nice(2))
3411 exit(0);
3412 exit(1);
3413 }
3414 ],
3415 ac_cv_broken_nice=yes,
3416 ac_cv_broken_nice=no,
3417 ac_cv_broken_nice=no)])
3418 AC_MSG_RESULT($ac_cv_broken_nice)
3419 if test "$ac_cv_broken_nice" = yes
3420 then
3421 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3422 [Define if nice() returns success/failure instead of the new priority.])
3423 fi
3425 AC_MSG_CHECKING(for broken poll())
3426 AC_TRY_RUN([
3427 #include <poll.h>
3429 int main (void)
3430 {
3431 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3433 close (42);
3435 int poll_test = poll (&poll_struct, 1, 0);
3437 if (poll_test < 0)
3438 {
3439 exit(0);
3440 }
3441 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3442 {
3443 exit(0);
3444 }
3445 else
3446 {
3447 exit(1);
3448 }
3449 }
3450 ],
3451 ac_cv_broken_poll=yes,
3452 ac_cv_broken_poll=no,
3453 ac_cv_broken_poll=no)
3454 AC_MSG_RESULT($ac_cv_broken_poll)
3455 if test "$ac_cv_broken_poll" = yes
3456 then
3457 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3458 [Define if poll() sets errno on invalid file descriptors.])
3459 fi
3461 # Before we can test tzset, we need to check if struct tm has a tm_zone
3462 # (which is not required by ISO C or UNIX spec) and/or if we support
3463 # tzname[]
3464 AC_STRUCT_TIMEZONE
3466 # check tzset(3) exists and works like we expect it to
3467 AC_MSG_CHECKING(for working tzset())
3468 AC_CACHE_VAL(ac_cv_working_tzset, [
3469 AC_TRY_RUN([
3470 #include <stdlib.h>
3471 #include <time.h>
3472 #include <string.h>
3474 #if HAVE_TZNAME
3475 extern char *tzname[];
3476 #endif
3478 int main()
3479 {
3480 /* Note that we need to ensure that not only does tzset(3)
3481 do 'something' with localtime, but it works as documented
3482 in the library reference and as expected by the test suite.
3483 This includes making sure that tzname is set properly if
3484 tm->tm_zone does not exist since it is the alternative way
3485 of getting timezone info.
3487 Red Hat 6.2 doesn't understand the southern hemisphere
3488 after New Year's Day.
3489 */
3491 time_t groundhogday = 1044144000; /* GMT-based */
3492 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3494 putenv("TZ=UTC+0");
3495 tzset();
3496 if (localtime(&groundhogday)->tm_hour != 0)
3497 exit(1);
3498 #if HAVE_TZNAME
3499 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3500 if (strcmp(tzname[0], "UTC") ||
3501 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3502 exit(1);
3503 #endif
3505 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3506 tzset();
3507 if (localtime(&groundhogday)->tm_hour != 19)
3508 exit(1);
3509 #if HAVE_TZNAME
3510 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3511 exit(1);
3512 #endif
3514 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3515 tzset();
3516 if (localtime(&groundhogday)->tm_hour != 11)
3517 exit(1);
3518 #if HAVE_TZNAME
3519 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3520 exit(1);
3521 #endif
3523 #if HAVE_STRUCT_TM_TM_ZONE
3524 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3525 exit(1);
3526 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3527 exit(1);
3528 #endif
3530 exit(0);
3531 }
3532 ],
3533 ac_cv_working_tzset=yes,
3534 ac_cv_working_tzset=no,
3535 ac_cv_working_tzset=no)])
3536 AC_MSG_RESULT($ac_cv_working_tzset)
3537 if test "$ac_cv_working_tzset" = yes
3538 then
3539 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3540 [Define if tzset() actually switches the local timezone in a meaningful way.])
3541 fi
3543 # Look for subsecond timestamps in struct stat
3544 AC_MSG_CHECKING(for tv_nsec in struct stat)
3545 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3546 AC_TRY_COMPILE([#include <sys/stat.h>], [
3547 struct stat st;
3548 st.st_mtim.tv_nsec = 1;
3549 ],
3550 ac_cv_stat_tv_nsec=yes,
3551 ac_cv_stat_tv_nsec=no,
3552 ac_cv_stat_tv_nsec=no))
3553 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3554 if test "$ac_cv_stat_tv_nsec" = yes
3555 then
3556 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3557 [Define if you have struct stat.st_mtim.tv_nsec])
3558 fi
3560 # Look for BSD style subsecond timestamps in struct stat
3561 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3562 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3563 AC_TRY_COMPILE([#include <sys/stat.h>], [
3564 struct stat st;
3565 st.st_mtimespec.tv_nsec = 1;
3566 ],
3567 ac_cv_stat_tv_nsec2=yes,
3568 ac_cv_stat_tv_nsec2=no,
3569 ac_cv_stat_tv_nsec2=no))
3570 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3571 if test "$ac_cv_stat_tv_nsec2" = yes
3572 then
3573 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3574 [Define if you have struct stat.st_mtimensec])
3575 fi
3577 # On HP/UX 11.0, mvwdelch is a block with a return statement
3578 AC_MSG_CHECKING(whether mvwdelch is an expression)
3579 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3580 AC_TRY_COMPILE([#include <curses.h>], [
3581 int rtn;
3582 rtn = mvwdelch(0,0,0);
3583 ], ac_cv_mvwdelch_is_expression=yes,
3584 ac_cv_mvwdelch_is_expression=no,
3585 ac_cv_mvwdelch_is_expression=yes))
3586 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3588 if test "$ac_cv_mvwdelch_is_expression" = yes
3589 then
3590 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3591 [Define if mvwdelch in curses.h is an expression.])
3592 fi
3594 AC_MSG_CHECKING(whether WINDOW has _flags)
3595 AC_CACHE_VAL(ac_cv_window_has_flags,
3596 AC_TRY_COMPILE([#include <curses.h>], [
3597 WINDOW *w;
3598 w->_flags = 0;
3599 ], ac_cv_window_has_flags=yes,
3600 ac_cv_window_has_flags=no,
3601 ac_cv_window_has_flags=no))
3602 AC_MSG_RESULT($ac_cv_window_has_flags)
3605 if test "$ac_cv_window_has_flags" = yes
3606 then
3607 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3608 [Define if WINDOW in curses.h offers a field _flags.])
3609 fi
3611 AC_MSG_CHECKING(for is_term_resized)
3612 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3613 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3614 AC_MSG_RESULT(yes),
3615 AC_MSG_RESULT(no)
3616 )
3618 AC_MSG_CHECKING(for resize_term)
3619 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3620 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3621 AC_MSG_RESULT(yes),
3622 AC_MSG_RESULT(no)
3623 )
3625 AC_MSG_CHECKING(for resizeterm)
3626 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3627 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3628 AC_MSG_RESULT(yes),
3629 AC_MSG_RESULT(no)
3630 )
3632 AC_MSG_CHECKING(for /dev/ptmx)
3634 if test -r /dev/ptmx
3635 then
3636 AC_MSG_RESULT(yes)
3637 AC_DEFINE(HAVE_DEV_PTMX, 1,
3638 [Define if we have /dev/ptmx.])
3639 else
3640 AC_MSG_RESULT(no)
3641 fi
3643 AC_MSG_CHECKING(for /dev/ptc)
3645 if test -r /dev/ptc
3646 then
3647 AC_MSG_RESULT(yes)
3648 AC_DEFINE(HAVE_DEV_PTC, 1,
3649 [Define if we have /dev/ptc.])
3650 else
3651 AC_MSG_RESULT(no)
3652 fi
3654 AC_MSG_CHECKING(for %zd printf() format support)
3655 AC_TRY_RUN([#include <stdio.h>
3656 #include <stddef.h>
3657 #include <string.h>
3659 #ifdef HAVE_SYS_TYPES_H
3660 #include <sys/types.h>
3661 #endif
3663 #ifdef HAVE_SSIZE_T
3664 typedef ssize_t Py_ssize_t;
3665 #elif SIZEOF_VOID_P == SIZEOF_LONG
3666 typedef long Py_ssize_t;
3667 #else
3668 typedef int Py_ssize_t;
3669 #endif
3671 int main()
3672 {
3673 char buffer[256];
3675 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3676 return 1;
3678 if (strcmp(buffer, "123"))
3679 return 1;
3681 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3682 return 1;
3684 if (strcmp(buffer, "-123"))
3685 return 1;
3687 return 0;
3688 }],
3689 [AC_MSG_RESULT(yes)
3690 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3691 AC_MSG_RESULT(no))
3693 AC_CHECK_TYPE(socklen_t,,
3694 AC_DEFINE(socklen_t,int,
3695 Define to `int' if <sys/socket.h> does not define.),[
3696 #ifdef HAVE_SYS_TYPES_H
3697 #include <sys/types.h>
3698 #endif
3699 #ifdef HAVE_SYS_SOCKET_H
3700 #include <sys/socket.h>
3701 #endif
3702 ])
3704 AC_MSG_CHECKING(for broken mbstowcs)
3705 AC_TRY_RUN([
3706 #include<stdlib.h>
3707 int main() {
3708 size_t len = -1;
3709 const char *str = "text";
3710 len = mbstowcs(NULL, str, 0);
3711 return (len != 4);
3712 }
3713 ],
3714 ac_cv_broken_mbstowcs=no,
3715 ac_cv_broken_mbstowcs=yes,
3716 ac_cv_broken_mbstowcs=no)
3717 AC_MSG_RESULT($ac_cv_broken_mbstowcs)
3718 if test "$ac_cv_broken_mbstowcs" = yes
3719 then
3720 AC_DEFINE(HAVE_BROKEN_MBSTOWCS, 1,
3721 [Define if mbstowcs(NULL, "text", 0) does not return the number of
3722 wide chars that would be converted.])
3723 fi
3725 # Check for --with-computed-gotos
3726 AC_MSG_CHECKING(for --with-computed-gotos)
3727 AC_ARG_WITH(computed-gotos,
3728 AC_HELP_STRING(--with-computed-gotos,
3729 Use computed gotos / threaded dispatch in evaluation loop (not available on all compilers)),
3730 [
3731 if test "$withval" != no
3732 then
3733 AC_DEFINE(USE_COMPUTED_GOTOS, 1,
3734 [Define if you want to use computed gotos in ceval.c.])
3735 AC_MSG_RESULT(yes)
3736 else AC_MSG_RESULT(no)
3737 fi],
3738 [AC_MSG_RESULT(no)])
3741 AC_SUBST(THREADHEADERS)
3743 for h in `(cd $srcdir;echo Python/thread_*.h)`
3744 do
3745 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3746 done
3748 AC_SUBST(SRCDIRS)
3749 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3750 AC_MSG_CHECKING(for build directories)
3751 for dir in $SRCDIRS; do
3752 if test ! -d $dir; then
3753 mkdir $dir
3754 fi
3755 done
3756 AC_MSG_RESULT(done)
3758 # generate output files
3759 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3760 AC_OUTPUT
3762 echo "creating Modules/Setup"
3763 if test ! -f Modules/Setup
3764 then
3765 cp $srcdir/Modules/Setup.dist Modules/Setup
3766 fi
3768 echo "creating Modules/Setup.local"
3769 if test ! -f Modules/Setup.local
3770 then
3771 echo "# Edit this file for local setup changes" >Modules/Setup.local
3772 fi
3774 echo "creating Makefile"
3775 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3776 -s Modules Modules/Setup.config \
3777 Modules/Setup.local Modules/Setup
3778 mv config.c Modules