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