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