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