| blob | 0f2ce8968c276682f29fe67454a2f05cfc21e822 |
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_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 ;;
752 esac
753 else # shared is disabled
754 case $ac_sys_system in
755 CYGWIN*)
756 BLDLIBRARY='$(LIBRARY)'
757 LDLIBRARY='libpython$(VERSION).dll.a'
758 ;;
759 esac
760 fi
762 AC_MSG_RESULT($LDLIBRARY)
764 AC_PROG_RANLIB
765 AC_SUBST(AR)
766 AC_CHECK_PROGS(AR, ar aal, ar)
768 # tweak ARFLAGS only if the user didn't set it on the command line
769 AC_SUBST(ARFLAGS)
770 if test -z "$ARFLAGS"
771 then
772 ARFLAGS="rc"
773 fi
775 AC_SUBST(SVNVERSION)
776 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
777 if test $SVNVERSION = found
778 then
779 SVNVERSION="svnversion \$(srcdir)"
780 else
781 SVNVERSION="echo Unversioned directory"
782 fi
784 case $MACHDEP in
785 bsdos*|hp*|HP*)
786 # install -d does not work on BSDI or HP-UX
787 if test -z "$INSTALL"
788 then
789 INSTALL="${srcdir}/install-sh -c"
790 fi
791 esac
792 AC_PROG_INSTALL
794 # Not every filesystem supports hard links
795 AC_SUBST(LN)
796 if test -z "$LN" ; then
797 case $ac_sys_system in
798 CYGWIN*) LN="ln -s";;
799 atheos*) LN="ln -s";;
800 *) LN=ln;;
801 esac
802 fi
804 # Check for --with-pydebug
805 AC_MSG_CHECKING(for --with-pydebug)
806 AC_ARG_WITH(pydebug,
807 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
808 [
809 if test "$withval" != no
810 then
811 AC_DEFINE(Py_DEBUG, 1,
812 [Define if you want to build an interpreter with many run-time checks.])
813 AC_MSG_RESULT(yes);
814 Py_DEBUG='true'
815 else AC_MSG_RESULT(no); Py_DEBUG='false'
816 fi],
817 [AC_MSG_RESULT(no)])
819 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
820 # merged with this chunk of code?
822 # Optimizer/debugger flags
823 # ------------------------
824 # (The following bit of code is complicated enough - please keep things
825 # indented properly. Just pretend you're editing Python code. ;-)
827 # There are two parallel sets of case statements below, one that checks to
828 # see if OPT was set and one that does BASECFLAGS setting based upon
829 # compiler and platform. BASECFLAGS tweaks need to be made even if the
830 # user set OPT.
832 # tweak OPT based on compiler and platform, only if the user didn't set
833 # it on the command line
834 AC_SUBST(OPT)
835 if test "${OPT-unset}" = "unset"
836 then
837 case $GCC in
838 yes)
839 if test "$CC" != 'g++' ; then
840 STRICT_PROTO="-Wstrict-prototypes"
841 fi
842 # For gcc 4.x we need to use -fwrapv so lets check if its supported
843 if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
844 WRAP="-fwrapv"
845 fi
846 case $ac_cv_prog_cc_g in
847 yes)
848 if test "$Py_DEBUG" = 'true' ; then
849 # Optimization messes up debuggers, so turn it off for
850 # debug builds.
851 OPT="-g -Wall $STRICT_PROTO"
852 else
853 OPT="-g $WRAP -O3 -Wall $STRICT_PROTO"
854 fi
855 ;;
856 *)
857 OPT="-O3 -Wall $STRICT_PROTO"
858 ;;
859 esac
860 case $ac_sys_system in
861 SCO_SV*) OPT="$OPT -m486 -DSCO5"
862 ;;
863 esac
864 ;;
866 *)
867 OPT="-O"
868 ;;
869 esac
870 fi
872 AC_SUBST(BASECFLAGS)
874 # The -arch flags for universal builds on OSX
875 UNIVERSAL_ARCH_FLAGS=
876 AC_SUBST(UNIVERSAL_ARCH_FLAGS)
878 # tweak BASECFLAGS based on compiler and platform
879 case $GCC in
880 yes)
881 # Python violates C99 rules, by casting between incompatible
882 # pointer types. GCC may generate bad code as a result of that,
883 # so use -fno-strict-aliasing if supported.
884 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
885 ac_save_cc="$CC"
886 CC="$CC -fno-strict-aliasing"
887 AC_TRY_RUN([int main() { return 0; }],
888 ac_cv_no_strict_aliasing_ok=yes,
889 ac_cv_no_strict_aliasing_ok=no,
890 ac_cv_no_strict_aliasing_ok=no)
891 CC="$ac_save_cc"
892 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
893 if test $ac_cv_no_strict_aliasing_ok = yes
894 then
895 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
896 fi
898 # if using gcc on alpha, use -mieee to get (near) full IEEE 754
899 # support. Without this, treatment of subnormals doesn't follow
900 # the standard.
901 case $ac_sys_machine in
902 alpha*)
903 BASECFLAGS="$BASECFLAGS -mieee"
904 ;;
905 esac
907 case $ac_sys_system in
908 SCO_SV*)
909 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
910 ;;
911 # is there any other compiler on Darwin besides gcc?
912 Darwin*)
913 # -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd
914 # used to be here, but non-Apple gcc doesn't accept them.
915 if test "${CC}" = gcc
916 then
917 AC_MSG_CHECKING(which compiler should be used)
918 case "${UNIVERSALSDK}" in
919 */MacOSX10.4u.sdk)
920 # Build using 10.4 SDK, force usage of gcc when the
921 # compiler is gcc, otherwise the user will get very
922 # confusing error messages when building on OSX 10.6
923 CC=gcc-4.0
924 CPP=cpp-4.0
925 ;;
926 esac
927 AC_MSG_RESULT($CC)
928 fi
931 if test "${enable_universalsdk}"; then
932 UNIVERSAL_ARCH_FLAGS=""
933 if test "$UNIVERSAL_ARCHS" = "32-bit" ; then
934 ARCH_RUN_32BIT=""
935 UNIVERSAL_ARCH_FLAGS="-arch ppc -arch i386"
937 elif test "$UNIVERSAL_ARCHS" = "64-bit" ; then
938 ARCH_RUN_32BIT="true"
939 UNIVERSAL_ARCH_FLAGS="-arch ppc64 -arch x86_64"
941 elif test "$UNIVERSAL_ARCHS" = "all" ; then
942 ARCH_RUN_32BIT="/usr/bin/arch -i386 -ppc"
943 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch ppc64 -arch x86_64"
944 LIPO_32BIT_FLAGS="-extract i386 -extract ppc7400"
945 LIPO_64BIT_FLAGS="-extract x86_64 -extract ppc64"
947 elif test "$UNIVERSAL_ARCHS" = "intel" ; then
948 ARCH_RUN_32BIT="/usr/bin/arch -i386"
949 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch x86_64"
950 LIPO_32BIT_FLAGS="-extract i386"
951 LIPO_64BIT_FLAGS="-extract x86_64"
953 elif test "$UNIVERSAL_ARCHS" = "3-way" ; then
954 ARCH_RUN_32BIT="/usr/bin/arch -i386 -ppc"
955 UNIVERSAL_ARCH_FLAGS="-arch i386 -arch ppc -arch x86_64"
956 LIPO_32BIT_FLAGS="-extract i386 -extract ppc7400"
957 LIPO_64BIT_FLAGS="-extract x86_64"
959 else
960 AC_MSG_ERROR([proper usage is --with-universal-arch=32-bit|64-bit|all|intel|3-way])
962 fi
965 CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
966 if test "${UNIVERSALSDK}" != "/"
967 then
968 CFLAGS="-isysroot ${UNIVERSALSDK} ${CFLAGS}"
969 LDFLAGS="-isysroot ${UNIVERSALSDK} ${LDFLAGS}"
970 CPPFLAGSFLAGS="-isysroot ${UNIVERSALSDK} ${CPPFLAGS}"
971 fi
972 fi
974 # Calculate the right deployment target for this build.
975 #
976 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
977 if test ${cur_target} '>' 10.2; then
978 cur_target=10.3
979 if test ${enable_universalsdk}; then
980 if test "${UNIVERSAL_ARCHS}" = "all"; then
981 # Ensure that the default platform for a
982 # 4-way universal build is OSX 10.5,
983 # that's the first OS release where
984 # 4-way builds make sense.
985 cur_target='10.5'
987 elif test "${UNIVERSAL_ARCHS}" = "3-way"; then
988 cur_target='10.5'
990 elif test "${UNIVERSAL_ARCHS}" = "intel"; then
991 cur_target='10.5'
993 elif test "${UNIVERSAL_ARCHS}" = "64-bit"; then
994 cur_target='10.5'
995 fi
996 else
997 if test `/usr/bin/arch` = "i386"; then
998 # On Intel macs default to a deployment
999 # target of 10.4, that's the first OSX
1000 # release with Intel support.
1001 cur_target="10.4"
1002 fi
1003 fi
1004 fi
1005 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1007 # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
1008 # environment with a value that is the same as what we'll use
1009 # in the Makefile to ensure that we'll get the same compiler
1010 # environment during configure and build time.
1011 MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
1012 export MACOSX_DEPLOYMENT_TARGET
1013 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
1015 ;;
1016 OSF*)
1017 BASECFLAGS="$BASECFLAGS -mieee"
1018 ;;
1019 esac
1020 ;;
1022 *)
1023 case $ac_sys_system in
1024 OpenUNIX*|UnixWare*)
1025 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
1026 ;;
1027 OSF*)
1028 BASECFLAGS="$BASECFLAGS -ieee -std"
1029 ;;
1030 SCO_SV*)
1031 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
1032 ;;
1033 esac
1034 ;;
1035 esac
1037 if test "$Py_DEBUG" = 'true'; then
1038 :
1039 else
1040 OPT="-DNDEBUG $OPT"
1041 fi
1043 if test "$ac_arch_flags"
1044 then
1045 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
1046 fi
1048 # disable check for icc since it seems to pass, but generates a warning
1049 if test "$CC" = icc
1050 then
1051 ac_cv_opt_olimit_ok=no
1052 fi
1054 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
1055 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
1056 [ac_save_cc="$CC"
1057 CC="$CC -OPT:Olimit=0"
1058 AC_TRY_RUN([int main() { return 0; }],
1059 ac_cv_opt_olimit_ok=yes,
1060 ac_cv_opt_olimit_ok=no,
1061 ac_cv_opt_olimit_ok=no)
1062 CC="$ac_save_cc"])
1063 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
1064 if test $ac_cv_opt_olimit_ok = yes; then
1065 case $ac_sys_system in
1066 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
1067 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
1068 # environment?
1069 Darwin*)
1070 ;;
1071 *)
1072 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
1073 ;;
1074 esac
1075 else
1076 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
1077 AC_CACHE_VAL(ac_cv_olimit_ok,
1078 [ac_save_cc="$CC"
1079 CC="$CC -Olimit 1500"
1080 AC_TRY_RUN([int main() { return 0; }],
1081 ac_cv_olimit_ok=yes,
1082 ac_cv_olimit_ok=no,
1083 ac_cv_olimit_ok=no)
1084 CC="$ac_save_cc"])
1085 AC_MSG_RESULT($ac_cv_olimit_ok)
1086 if test $ac_cv_olimit_ok = yes; then
1087 BASECFLAGS="$BASECFLAGS -Olimit 1500"
1088 fi
1089 fi
1091 # Check whether GCC supports PyArg_ParseTuple format
1092 if test "$GCC" = "yes"
1093 then
1094 AC_MSG_CHECKING(whether gcc supports ParseTuple __format__)
1095 save_CFLAGS=$CFLAGS
1096 CFLAGS="$CFLAGS -Werror"
1097 AC_TRY_COMPILE([
1098 void f(char*,...)__attribute((format(PyArg_ParseTuple, 1, 2)));
1099 ],,
1100 AC_DEFINE(HAVE_ATTRIBUTE_FORMAT_PARSETUPLE, 1, [Define if GCC supports __attribute__((format(PyArg_ParseTuple, 2, 3)))])
1101 AC_MSG_RESULT(yes),
1102 AC_MSG_RESULT(no)
1103 )
1104 CFLAGS=$save_CFLAGS
1105 fi
1107 # On some compilers, pthreads are available without further options
1108 # (e.g. MacOS X). On some of these systems, the compiler will not
1109 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
1110 # So we have to see first whether pthreads are available without
1111 # options before we can check whether -Kpthread improves anything.
1112 AC_MSG_CHECKING(whether pthreads are available without options)
1113 AC_CACHE_VAL(ac_cv_pthread_is_default,
1114 [AC_TRY_RUN([
1115 #include <pthread.h>
1117 void* routine(void* p){return NULL;}
1119 int main(){
1120 pthread_t p;
1121 if(pthread_create(&p,NULL,routine,NULL)!=0)
1122 return 1;
1123 (void)pthread_detach(p);
1124 return 0;
1125 }
1126 ],
1127 [
1128 ac_cv_pthread_is_default=yes
1129 ac_cv_kthread=no
1130 ac_cv_pthread=no
1131 ],
1132 ac_cv_pthread_is_default=no,
1133 ac_cv_pthread_is_default=no)
1134 ])
1135 AC_MSG_RESULT($ac_cv_pthread_is_default)
1138 if test $ac_cv_pthread_is_default = yes
1139 then
1140 ac_cv_kpthread=no
1141 else
1142 # -Kpthread, if available, provides the right #defines
1143 # and linker options to make pthread_create available
1144 # Some compilers won't report that they do not support -Kpthread,
1145 # so we need to run a program to see whether it really made the
1146 # function available.
1147 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
1148 AC_CACHE_VAL(ac_cv_kpthread,
1149 [ac_save_cc="$CC"
1150 CC="$CC -Kpthread"
1151 AC_TRY_RUN([
1152 #include <pthread.h>
1154 void* routine(void* p){return NULL;}
1156 int main(){
1157 pthread_t p;
1158 if(pthread_create(&p,NULL,routine,NULL)!=0)
1159 return 1;
1160 (void)pthread_detach(p);
1161 return 0;
1162 }
1163 ],
1164 ac_cv_kpthread=yes,
1165 ac_cv_kpthread=no,
1166 ac_cv_kpthread=no)
1167 CC="$ac_save_cc"])
1168 AC_MSG_RESULT($ac_cv_kpthread)
1169 fi
1171 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
1172 then
1173 # -Kthread, if available, provides the right #defines
1174 # and linker options to make pthread_create available
1175 # Some compilers won't report that they do not support -Kthread,
1176 # so we need to run a program to see whether it really made the
1177 # function available.
1178 AC_MSG_CHECKING(whether $CC accepts -Kthread)
1179 AC_CACHE_VAL(ac_cv_kthread,
1180 [ac_save_cc="$CC"
1181 CC="$CC -Kthread"
1182 AC_TRY_RUN([
1183 #include <pthread.h>
1185 void* routine(void* p){return NULL;}
1187 int main(){
1188 pthread_t p;
1189 if(pthread_create(&p,NULL,routine,NULL)!=0)
1190 return 1;
1191 (void)pthread_detach(p);
1192 return 0;
1193 }
1194 ],
1195 ac_cv_kthread=yes,
1196 ac_cv_kthread=no,
1197 ac_cv_kthread=no)
1198 CC="$ac_save_cc"])
1199 AC_MSG_RESULT($ac_cv_kthread)
1200 fi
1202 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
1203 then
1204 # -pthread, if available, provides the right #defines
1205 # and linker options to make pthread_create available
1206 # Some compilers won't report that they do not support -pthread,
1207 # so we need to run a program to see whether it really made the
1208 # function available.
1209 AC_MSG_CHECKING(whether $CC accepts -pthread)
1210 AC_CACHE_VAL(ac_cv_thread,
1211 [ac_save_cc="$CC"
1212 CC="$CC -pthread"
1213 AC_TRY_RUN([
1214 #include <pthread.h>
1216 void* routine(void* p){return NULL;}
1218 int main(){
1219 pthread_t p;
1220 if(pthread_create(&p,NULL,routine,NULL)!=0)
1221 return 1;
1222 (void)pthread_detach(p);
1223 return 0;
1224 }
1225 ],
1226 ac_cv_pthread=yes,
1227 ac_cv_pthread=no,
1228 ac_cv_pthread=no)
1229 CC="$ac_save_cc"])
1230 AC_MSG_RESULT($ac_cv_pthread)
1231 fi
1233 # If we have set a CC compiler flag for thread support then
1234 # check if it works for CXX, too.
1235 ac_cv_cxx_thread=no
1236 if test ! -z "$CXX"
1237 then
1238 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1239 ac_save_cxx="$CXX"
1241 if test "$ac_cv_kpthread" = "yes"
1242 then
1243 CXX="$CXX -Kpthread"
1244 ac_cv_cxx_thread=yes
1245 elif test "$ac_cv_kthread" = "yes"
1246 then
1247 CXX="$CXX -Kthread"
1248 ac_cv_cxx_thread=yes
1249 elif test "$ac_cv_pthread" = "yes"
1250 then
1251 CXX="$CXX -pthread"
1252 ac_cv_cxx_thread=yes
1253 fi
1255 if test $ac_cv_cxx_thread = yes
1256 then
1257 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1258 $CXX -c conftest.$ac_ext 2>&5
1259 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1260 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1261 then
1262 ac_cv_cxx_thread=yes
1263 else
1264 ac_cv_cxx_thread=no
1265 fi
1266 rm -fr conftest*
1267 fi
1268 AC_MSG_RESULT($ac_cv_cxx_thread)
1269 fi
1270 CXX="$ac_save_cxx"
1272 dnl # check for ANSI or K&R ("traditional") preprocessor
1273 dnl AC_MSG_CHECKING(for C preprocessor type)
1274 dnl AC_TRY_COMPILE([
1275 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1276 dnl int foo;
1277 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1278 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1279 dnl AC_MSG_RESULT($cpp_type)
1281 # checks for header files
1282 AC_HEADER_STDC
1283 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1284 fcntl.h grp.h \
1285 ieeefp.h io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
1286 shadow.h signal.h stdint.h stropts.h termios.h thread.h \
1287 unistd.h utime.h \
1288 sys/audioio.h sys/bsdtty.h sys/epoll.h sys/event.h sys/file.h sys/loadavg.h \
1289 sys/lock.h sys/mkdev.h sys/modem.h \
1290 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1291 sys/termio.h sys/time.h \
1292 sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1293 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1294 bluetooth/bluetooth.h linux/tipc.h)
1295 AC_HEADER_DIRENT
1296 AC_HEADER_MAJOR
1298 # On Solaris, term.h requires curses.h
1299 AC_CHECK_HEADERS(term.h,,,[
1300 #ifdef HAVE_CURSES_H
1301 #include <curses.h>
1302 #endif
1303 ])
1305 # On Linux, netlink.h requires asm/types.h
1306 AC_CHECK_HEADERS(linux/netlink.h,,,[
1307 #ifdef HAVE_ASM_TYPES_H
1308 #include <asm/types.h>
1309 #endif
1310 #ifdef HAVE_SYS_SOCKET_H
1311 #include <sys/socket.h>
1312 #endif
1313 ])
1315 # checks for typedefs
1316 was_it_defined=no
1317 AC_MSG_CHECKING(for clock_t in time.h)
1318 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1319 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1320 ])
1321 AC_MSG_RESULT($was_it_defined)
1323 # Check whether using makedev requires defining _OSF_SOURCE
1324 AC_MSG_CHECKING(for makedev)
1325 AC_TRY_LINK([#include <sys/types.h> ],
1326 [ makedev(0, 0) ],
1327 ac_cv_has_makedev=yes,
1328 ac_cv_has_makedev=no)
1329 if test "$ac_cv_has_makedev" = "no"; then
1330 # we didn't link, try if _OSF_SOURCE will allow us to link
1331 AC_TRY_LINK([
1332 #define _OSF_SOURCE 1
1333 #include <sys/types.h>
1334 ],
1335 [ makedev(0, 0) ],
1336 ac_cv_has_makedev=yes,
1337 ac_cv_has_makedev=no)
1338 if test "$ac_cv_has_makedev" = "yes"; then
1339 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1340 fi
1341 fi
1342 AC_MSG_RESULT($ac_cv_has_makedev)
1343 if test "$ac_cv_has_makedev" = "yes"; then
1344 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1345 fi
1347 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1348 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1349 # defined, but the compiler does not support pragma redefine_extname,
1350 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1351 # structures (such as rlimit64) without declaring them. As a
1352 # work-around, disable LFS on such configurations
1354 use_lfs=yes
1355 AC_MSG_CHECKING(Solaris LFS bug)
1356 AC_TRY_COMPILE([
1357 #define _LARGEFILE_SOURCE 1
1358 #define _FILE_OFFSET_BITS 64
1359 #include <sys/resource.h>
1360 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1361 AC_MSG_RESULT($sol_lfs_bug)
1362 if test "$sol_lfs_bug" = "yes"; then
1363 use_lfs=no
1364 fi
1366 if test "$use_lfs" = "yes"; then
1367 # Two defines needed to enable largefile support on various platforms
1368 # These may affect some typedefs
1369 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1370 [This must be defined on some systems to enable large file support.])
1371 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1372 [This must be set to 64 on some systems to enable large file support.])
1373 fi
1375 # Add some code to confdefs.h so that the test for off_t works on SCO
1376 cat >> confdefs.h <<\EOF
1377 #if defined(SCO_DS)
1378 #undef _OFF_T
1379 #endif
1380 EOF
1382 # Type availability checks
1383 AC_TYPE_MODE_T
1384 AC_TYPE_OFF_T
1385 AC_TYPE_PID_T
1386 AC_TYPE_SIGNAL
1387 AC_TYPE_SIZE_T
1388 AC_TYPE_UID_T
1389 AC_TYPE_UINT32_T
1390 AC_TYPE_UINT64_T
1391 AC_TYPE_INT32_T
1392 AC_TYPE_INT64_T
1393 AC_CHECK_TYPE(ssize_t,
1394 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1396 # Sizes of various common basic types
1397 # ANSI C requires sizeof(char) == 1, so no need to check it
1398 AC_CHECK_SIZEOF(int, 4)
1399 AC_CHECK_SIZEOF(long, 4)
1400 AC_CHECK_SIZEOF(void *, 4)
1401 AC_CHECK_SIZEOF(short, 2)
1402 AC_CHECK_SIZEOF(float, 4)
1403 AC_CHECK_SIZEOF(double, 8)
1404 AC_CHECK_SIZEOF(fpos_t, 4)
1405 AC_CHECK_SIZEOF(size_t, 4)
1406 AC_CHECK_SIZEOF(pid_t, 4)
1408 AC_MSG_CHECKING(for long long support)
1409 have_long_long=no
1410 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1411 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1412 have_long_long=yes
1413 ])
1414 AC_MSG_RESULT($have_long_long)
1415 if test "$have_long_long" = yes ; then
1416 AC_CHECK_SIZEOF(long long, 8)
1417 fi
1419 AC_MSG_CHECKING(for long double support)
1420 have_long_double=no
1421 AC_TRY_COMPILE([], [long double x; x = (long double)0;], [
1422 AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define this if you have the type long double.])
1423 have_long_double=yes
1424 ])
1425 AC_MSG_RESULT($have_long_double)
1426 if test "$have_long_double" = yes ; then
1427 AC_CHECK_SIZEOF(long double, 16)
1428 fi
1431 AC_MSG_CHECKING(for _Bool support)
1432 have_c99_bool=no
1433 AC_TRY_COMPILE([], [_Bool x; x = (_Bool)0;], [
1434 AC_DEFINE(HAVE_C99_BOOL, 1, [Define this if you have the type _Bool.])
1435 have_c99_bool=yes
1436 ])
1437 AC_MSG_RESULT($have_c99_bool)
1438 if test "$have_c99_bool" = yes ; then
1439 AC_CHECK_SIZEOF(_Bool, 1)
1440 fi
1442 AC_CHECK_TYPES(uintptr_t,
1443 [AC_CHECK_SIZEOF(uintptr_t, 4)],
1444 [], [#ifdef HAVE_STDINT_H
1445 #include <stdint.h>
1446 #endif])
1449 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1450 AC_MSG_CHECKING(size of off_t)
1451 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1452 [AC_TRY_RUN([#include <stdio.h>
1453 #include <sys/types.h>
1454 main()
1455 {
1456 FILE *f=fopen("conftestval", "w");
1457 if (!f) exit(1);
1458 fprintf(f, "%d\n", sizeof(off_t));
1459 exit(0);
1460 }],
1461 ac_cv_sizeof_off_t=`cat conftestval`,
1462 ac_cv_sizeof_off_t=0,
1463 ac_cv_sizeof_off_t=4)
1464 ])
1465 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1466 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1467 [The number of bytes in an off_t.])
1469 AC_MSG_CHECKING(whether to enable large file support)
1470 if test "$have_long_long" = yes
1471 then
1472 if test "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1473 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1474 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1475 [Defined to enable large file support when an off_t is bigger than a long
1476 and long long is available and at least as big as an off_t. You may need
1477 to add some flags for configuration and compilation to enable this mode.
1478 (For Solaris and Linux, the necessary defines are already defined.)])
1479 AC_MSG_RESULT(yes)
1480 else
1481 AC_MSG_RESULT(no)
1482 fi
1483 else
1484 AC_MSG_RESULT(no)
1485 fi
1487 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1488 AC_MSG_CHECKING(size of time_t)
1489 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1490 [AC_TRY_RUN([#include <stdio.h>
1491 #include <time.h>
1492 main()
1493 {
1494 FILE *f=fopen("conftestval", "w");
1495 if (!f) exit(1);
1496 fprintf(f, "%d\n", sizeof(time_t));
1497 exit(0);
1498 }],
1499 ac_cv_sizeof_time_t=`cat conftestval`,
1500 ac_cv_sizeof_time_t=0,
1501 ac_cv_sizeof_time_t=4)
1502 ])
1503 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1504 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1505 [The number of bytes in a time_t.])
1508 # if have pthread_t then define SIZEOF_PTHREAD_T
1509 ac_save_cc="$CC"
1510 if test "$ac_cv_kpthread" = "yes"
1511 then CC="$CC -Kpthread"
1512 elif test "$ac_cv_kthread" = "yes"
1513 then CC="$CC -Kthread"
1514 elif test "$ac_cv_pthread" = "yes"
1515 then CC="$CC -pthread"
1516 fi
1517 AC_MSG_CHECKING(for pthread_t)
1518 have_pthread_t=no
1519 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1520 AC_MSG_RESULT($have_pthread_t)
1521 if test "$have_pthread_t" = yes ; then
1522 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1523 AC_MSG_CHECKING(size of pthread_t)
1524 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1525 [AC_TRY_RUN([#include <stdio.h>
1526 #include <pthread.h>
1527 main()
1528 {
1529 FILE *f=fopen("conftestval", "w");
1530 if (!f) exit(1);
1531 fprintf(f, "%d\n", sizeof(pthread_t));
1532 exit(0);
1533 }],
1534 ac_cv_sizeof_pthread_t=`cat conftestval`,
1535 ac_cv_sizeof_pthread_t=0,
1536 ac_cv_sizeof_pthread_t=4)
1537 ])
1538 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1539 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1540 [The number of bytes in a pthread_t.])
1541 fi
1542 CC="$ac_save_cc"
1546 AC_SUBST(OTHER_LIBTOOL_OPT)
1547 case $ac_sys_system/$ac_sys_release in
1548 Darwin/@<:@01567@:>@\..*)
1549 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1550 ;;
1551 Darwin/*)
1552 OTHER_LIBTOOL_OPT=""
1553 ;;
1554 esac
1557 ARCH_RUN_32BIT=""
1558 AC_SUBST(LIBTOOL_CRUFT)
1559 case $ac_sys_system/$ac_sys_release in
1560 Darwin/@<:@01567@:>@\..*)
1561 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1562 if test "${enable_universalsdk}"; then
1563 :
1564 else
1565 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `/usr/bin/arch`"
1566 fi
1567 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1568 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1569 Darwin/*)
1570 gcc_version=`gcc -dumpversion`
1571 if test ${gcc_version} '<' 4.0
1572 then
1573 LIBTOOL_CRUFT="-lcc_dynamic"
1574 else
1575 LIBTOOL_CRUFT=""
1576 fi
1577 AC_TRY_RUN([
1578 #include <unistd.h>
1579 int main(int argc, char*argv[])
1580 {
1581 if (sizeof(long) == 4) {
1582 return 0;
1583 } else {
1584 return 1;
1585 }
1586 }
1587 ], ac_osx_32bit=yes,
1588 ac_osx_32bit=no,
1589 ac_osx_32bit=yes)
1591 if test "${ac_osx_32bit}" = "yes"; then
1592 case `/usr/bin/arch` in
1593 i386)
1594 MACOSX_DEFAULT_ARCH="i386"
1595 ;;
1596 ppc)
1597 MACOSX_DEFAULT_ARCH="ppc"
1598 ;;
1599 *)
1600 AC_MSG_ERROR([Unexpected output of 'arch' on OSX])
1601 ;;
1602 esac
1603 else
1604 case `/usr/bin/arch` in
1605 i386)
1606 MACOSX_DEFAULT_ARCH="x86_64"
1607 ;;
1608 ppc)
1609 MACOSX_DEFAULT_ARCH="ppc64"
1610 ;;
1611 *)
1612 AC_MSG_ERROR([Unexpected output of 'arch' on OSX])
1613 ;;
1614 esac
1616 #ARCH_RUN_32BIT="true"
1617 fi
1619 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only ${MACOSX_DEFAULT_ARCH}"
1620 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1621 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1622 esac
1624 AC_MSG_CHECKING(for --enable-framework)
1625 if test "$enable_framework"
1626 then
1627 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1628 # -F. is needed to allow linking to the framework while
1629 # in the build location.
1630 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1631 [Define if you want to produce an OpenStep/Rhapsody framework
1632 (shared library plus accessory files).])
1633 AC_MSG_RESULT(yes)
1634 if test $enable_shared = "yes"
1635 then
1636 AC_MSG_ERROR([Specifying both --enable-shared and --enable-framework is not supported, use only --enable-framework instead])
1637 fi
1638 else
1639 AC_MSG_RESULT(no)
1640 fi
1642 AC_MSG_CHECKING(for dyld)
1643 case $ac_sys_system/$ac_sys_release in
1644 Darwin/*)
1645 AC_DEFINE(WITH_DYLD, 1,
1646 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1647 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1648 linker (rld). Dyld is necessary to support frameworks.])
1649 AC_MSG_RESULT(always on for Darwin)
1650 ;;
1651 *)
1652 AC_MSG_RESULT(no)
1653 ;;
1654 esac
1656 # Set info about shared libraries.
1657 AC_SUBST(SO)
1658 AC_SUBST(LDSHARED)
1659 AC_SUBST(BLDSHARED)
1660 AC_SUBST(CCSHARED)
1661 AC_SUBST(LINKFORSHARED)
1662 # SO is the extension of shared libraries `(including the dot!)
1663 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1664 AC_MSG_CHECKING(SO)
1665 if test -z "$SO"
1666 then
1667 case $ac_sys_system in
1668 hp*|HP*)
1669 case `uname -m` in
1670 ia64) SO=.so;;
1671 *) SO=.sl;;
1672 esac
1673 ;;
1674 CYGWIN*) SO=.dll;;
1675 *) SO=.so;;
1676 esac
1677 else
1678 # this might also be a termcap variable, see #610332
1679 echo
1680 echo '====================================================================='
1681 echo '+ +'
1682 echo '+ WARNING: You have set SO in your environment. +'
1683 echo '+ Do you really mean to change the extension for shared libraries? +'
1684 echo '+ Continuing in 10 seconds to let you to ponder. +'
1685 echo '+ +'
1686 echo '====================================================================='
1687 sleep 10
1688 fi
1689 AC_MSG_RESULT($SO)
1691 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1692 # LDSHARED is the ld *command* used to create shared library
1693 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1694 # (Shared libraries in this instance are shared modules to be loaded into
1695 # Python, as opposed to building Python itself as a shared library.)
1696 AC_MSG_CHECKING(LDSHARED)
1697 if test -z "$LDSHARED"
1698 then
1699 case $ac_sys_system/$ac_sys_release in
1700 AIX*)
1701 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1702 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1703 ;;
1704 IRIX/5*) LDSHARED="ld -shared";;
1705 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1706 SunOS/5*)
1707 if test "$GCC" = "yes"
1708 then LDSHARED='$(CC) -shared'
1709 else LDSHARED='$(CC) -G';
1710 fi ;;
1711 hp*|HP*)
1712 if test "$GCC" = "yes"
1713 then LDSHARED='$(CC) -shared'
1714 else LDSHARED='ld -b';
1715 fi ;;
1716 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1717 Darwin/1.3*)
1718 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1719 if test "$enable_framework" ; then
1720 # Link against the framework. All externals should be defined.
1721 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1722 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1723 else
1724 # No framework. Ignore undefined symbols, assuming they come from Python
1725 LDSHARED="$LDSHARED -undefined suppress"
1726 fi ;;
1727 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1728 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1729 if test "$enable_framework" ; then
1730 # Link against the framework. All externals should be defined.
1731 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1732 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1733 else
1734 # No framework, use the Python app as bundle-loader
1735 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1736 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1737 fi ;;
1738 Darwin/*)
1739 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1740 # This allows an extension to be used in any Python
1742 if test ${MACOSX_DEPLOYMENT_TARGET} '>' 10.2
1743 then
1744 if test "${enable_universalsdk}"; then
1745 LDFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1746 fi
1747 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1748 BLDSHARED="$LDSHARED"
1749 else
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, use the Python app as bundle-loader
1757 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1758 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1759 fi
1760 fi
1761 ;;
1762 Linux*|GNU*|QNX*) LDSHARED='$(CC) -shared';;
1763 BSD/OS*/4*) LDSHARED="gcc -shared";;
1764 FreeBSD*)
1765 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1766 then
1767 LDSHARED="$CC -shared ${LDFLAGS}"
1768 else
1769 LDSHARED="ld -Bshareable ${LDFLAGS}"
1770 fi;;
1771 OpenBSD*)
1772 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1773 then
1774 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1775 else
1776 case `uname -r` in
1777 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1778 LDSHARED="ld -Bshareable ${LDFLAGS}"
1779 ;;
1780 *)
1781 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1782 ;;
1783 esac
1784 fi;;
1785 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1786 OpenUNIX*|UnixWare*)
1787 if test "$GCC" = "yes"
1788 then LDSHARED='$(CC) -shared'
1789 else LDSHARED='$(CC) -G'
1790 fi;;
1791 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1792 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1793 atheos*) LDSHARED="gcc -shared";;
1794 *) LDSHARED="ld";;
1795 esac
1796 fi
1797 AC_MSG_RESULT($LDSHARED)
1798 BLDSHARED=${BLDSHARED-$LDSHARED}
1799 # CCSHARED are the C *flags* used to create objects to go into a shared
1800 # library (module) -- this is only needed for a few systems
1801 AC_MSG_CHECKING(CCSHARED)
1802 if test -z "$CCSHARED"
1803 then
1804 case $ac_sys_system/$ac_sys_release in
1805 SunOS*) if test "$GCC" = yes;
1806 then CCSHARED="-fPIC";
1807 elif test `uname -p` = sparc;
1808 then CCSHARED="-xcode=pic32";
1809 else CCSHARED="-Kpic";
1810 fi;;
1811 hp*|HP*) if test "$GCC" = yes;
1812 then CCSHARED="-fPIC";
1813 else CCSHARED="+z";
1814 fi;;
1815 Linux*|GNU*) CCSHARED="-fPIC";;
1816 BSD/OS*/4*) CCSHARED="-fpic";;
1817 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1818 OpenUNIX*|UnixWare*)
1819 if test "$GCC" = "yes"
1820 then CCSHARED="-fPIC"
1821 else CCSHARED="-KPIC"
1822 fi;;
1823 SCO_SV*)
1824 if test "$GCC" = "yes"
1825 then CCSHARED="-fPIC"
1826 else CCSHARED="-Kpic -belf"
1827 fi;;
1828 IRIX*/6*) case $CC in
1829 *gcc*) CCSHARED="-shared";;
1830 *) CCSHARED="";;
1831 esac;;
1832 atheos*) CCSHARED="-fPIC";;
1833 esac
1834 fi
1835 AC_MSG_RESULT($CCSHARED)
1836 # LINKFORSHARED are the flags passed to the $(CC) command that links
1837 # the python executable -- this is only needed for a few systems
1838 AC_MSG_CHECKING(LINKFORSHARED)
1839 if test -z "$LINKFORSHARED"
1840 then
1841 case $ac_sys_system/$ac_sys_release in
1842 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1843 hp*|HP*)
1844 LINKFORSHARED="-Wl,-E -Wl,+s";;
1845 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1846 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1847 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1848 # -u libsys_s pulls in all symbols in libsys
1849 Darwin/*)
1850 LINKFORSHARED="$extra_undefs -framework CoreFoundation"
1851 if test "$enable_framework"
1852 then
1853 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1854 fi
1855 LINKFORSHARED="$LINKFORSHARED";;
1856 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1857 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1858 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1859 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1860 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1861 then
1862 LINKFORSHARED="-Wl,--export-dynamic"
1863 fi;;
1864 SunOS/5*) case $CC in
1865 *gcc*)
1866 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1867 then
1868 LINKFORSHARED="-Xlinker --export-dynamic"
1869 fi;;
1870 esac;;
1871 CYGWIN*)
1872 if test $enable_shared = "no"
1873 then
1874 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1875 fi;;
1876 QNX*)
1877 # -Wl,-E causes the symbols to be added to the dynamic
1878 # symbol table so that they can be found when a module
1879 # is loaded. -N 2048K causes the stack size to be set
1880 # to 2048 kilobytes so that the stack doesn't overflow
1881 # when running test_compile.py.
1882 LINKFORSHARED='-Wl,-E -N 2048K';;
1883 esac
1884 fi
1885 AC_MSG_RESULT($LINKFORSHARED)
1888 AC_SUBST(CFLAGSFORSHARED)
1889 AC_MSG_CHECKING(CFLAGSFORSHARED)
1890 if test ! "$LIBRARY" = "$LDLIBRARY"
1891 then
1892 case $ac_sys_system in
1893 CYGWIN*)
1894 # Cygwin needs CCSHARED when building extension DLLs
1895 # but not when building the interpreter DLL.
1896 CFLAGSFORSHARED='';;
1897 *)
1898 CFLAGSFORSHARED='$(CCSHARED)'
1899 esac
1900 fi
1901 AC_MSG_RESULT($CFLAGSFORSHARED)
1903 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1904 # library (with --enable-shared).
1905 # For platforms on which shared libraries are not allowed to have unresolved
1906 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1907 # if it is not required, since it creates a dependency of the shared library
1908 # to LIBS. This, in turn, means that applications linking the shared libpython
1909 # don't need to link LIBS explicitly. The default should be only changed
1910 # on systems where this approach causes problems.
1911 AC_SUBST(SHLIBS)
1912 AC_MSG_CHECKING(SHLIBS)
1913 case "$ac_sys_system" in
1914 *)
1915 SHLIBS='$(LIBS)';;
1916 esac
1917 AC_MSG_RESULT($SHLIBS)
1920 # checks for libraries
1921 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1922 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1924 # only check for sem_init if thread support is requested
1925 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1926 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1927 # posix4 on Solaris 2.6
1928 # pthread (first!) on Linux
1929 fi
1931 # check if we need libintl for locale functions
1932 AC_CHECK_LIB(intl, textdomain,
1933 [AC_DEFINE(WITH_LIBINTL, 1,
1934 [Define to 1 if libintl is needed for locale functions.])
1935 LIBS="-lintl $LIBS"])
1937 # checks for system dependent C++ extensions support
1938 case "$ac_sys_system" in
1939 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1940 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1941 [loadAndInit("", 0, "")],
1942 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1943 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1944 and you want support for AIX C++ shared extension modules.])
1945 AC_MSG_RESULT(yes)],
1946 [AC_MSG_RESULT(no)]);;
1947 *) ;;
1948 esac
1950 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1951 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1952 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1954 AC_MSG_CHECKING(for --with-libs)
1955 AC_ARG_WITH(libs,
1956 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1957 [
1958 AC_MSG_RESULT($withval)
1959 LIBS="$withval $LIBS"
1960 ],
1961 [AC_MSG_RESULT(no)])
1963 # Check for use of the system libffi library
1964 AC_MSG_CHECKING(for --with-system-ffi)
1965 AC_ARG_WITH(system_ffi,
1966 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1968 AC_MSG_RESULT($with_system_ffi)
1970 # Check for --with-dbmliborder
1971 AC_MSG_CHECKING(for --with-dbmliborder)
1972 AC_ARG_WITH(dbmliborder,
1973 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'.]),
1974 [
1975 if test x$with_dbmliborder = xyes
1976 then
1977 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
1978 else
1979 for db in `echo $with_dbmliborder | sed 's/:/ /g'`; do
1980 if test x$db != xndbm && test x$db != xgdbm && test x$db != xbdb
1981 then
1982 AC_MSG_ERROR([proper usage is --with-dbmliborder=db1:db2:...])
1983 fi
1984 done
1985 fi])
1986 AC_MSG_RESULT($with_dbmliborder)
1988 # Determine if signalmodule should be used.
1989 AC_SUBST(USE_SIGNAL_MODULE)
1990 AC_SUBST(SIGNAL_OBJS)
1991 AC_MSG_CHECKING(for --with-signal-module)
1992 AC_ARG_WITH(signal-module,
1993 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1995 if test -z "$with_signal_module"
1996 then with_signal_module="yes"
1997 fi
1998 AC_MSG_RESULT($with_signal_module)
2000 if test "${with_signal_module}" = "yes"; then
2001 USE_SIGNAL_MODULE=""
2002 SIGNAL_OBJS=""
2003 else
2004 USE_SIGNAL_MODULE="#"
2005 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
2006 fi
2008 # This is used to generate Setup.config
2009 AC_SUBST(USE_THREAD_MODULE)
2010 USE_THREAD_MODULE=""
2012 AC_MSG_CHECKING(for --with-dec-threads)
2013 AC_SUBST(LDLAST)
2014 AC_ARG_WITH(dec-threads,
2015 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
2016 [
2017 AC_MSG_RESULT($withval)
2018 LDLAST=-threads
2019 if test "${with_thread+set}" != set; then
2020 with_thread="$withval";
2021 fi],
2022 [AC_MSG_RESULT(no)])
2024 # Templates for things AC_DEFINEd more than once.
2025 # For a single AC_DEFINE, no template is needed.
2026 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
2027 AH_TEMPLATE(_REENTRANT,
2028 [Define to force use of thread-safe errno, h_errno, and other functions])
2029 AH_TEMPLATE(WITH_THREAD,
2030 [Define if you want to compile in rudimentary thread support])
2032 AC_MSG_CHECKING(for --with-threads)
2033 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2034 AC_ARG_WITH(threads,
2035 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
2037 # --with-thread is deprecated, but check for it anyway
2038 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2039 AC_ARG_WITH(thread,
2040 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
2041 [with_threads=$with_thread])
2043 if test -z "$with_threads"
2044 then with_threads="yes"
2045 fi
2046 AC_MSG_RESULT($with_threads)
2048 AC_SUBST(THREADOBJ)
2049 if test "$with_threads" = "no"
2050 then
2051 USE_THREAD_MODULE="#"
2052 elif test "$ac_cv_pthread_is_default" = yes
2053 then
2054 AC_DEFINE(WITH_THREAD)
2055 # Defining _REENTRANT on system with POSIX threads should not hurt.
2056 AC_DEFINE(_REENTRANT)
2057 posix_threads=yes
2058 THREADOBJ="Python/thread.o"
2059 elif test "$ac_cv_kpthread" = "yes"
2060 then
2061 CC="$CC -Kpthread"
2062 if test "$ac_cv_cxx_thread" = "yes"; then
2063 CXX="$CXX -Kpthread"
2064 fi
2065 AC_DEFINE(WITH_THREAD)
2066 posix_threads=yes
2067 THREADOBJ="Python/thread.o"
2068 elif test "$ac_cv_kthread" = "yes"
2069 then
2070 CC="$CC -Kthread"
2071 if test "$ac_cv_cxx_thread" = "yes"; then
2072 CXX="$CXX -Kthread"
2073 fi
2074 AC_DEFINE(WITH_THREAD)
2075 posix_threads=yes
2076 THREADOBJ="Python/thread.o"
2077 elif test "$ac_cv_pthread" = "yes"
2078 then
2079 CC="$CC -pthread"
2080 if test "$ac_cv_cxx_thread" = "yes"; then
2081 CXX="$CXX -pthread"
2082 fi
2083 AC_DEFINE(WITH_THREAD)
2084 posix_threads=yes
2085 THREADOBJ="Python/thread.o"
2086 else
2087 if test ! -z "$with_threads" -a -d "$with_threads"
2088 then LDFLAGS="$LDFLAGS -L$with_threads"
2089 fi
2090 if test ! -z "$withval" -a -d "$withval"
2091 then LDFLAGS="$LDFLAGS -L$withval"
2092 fi
2094 # According to the POSIX spec, a pthreads implementation must
2095 # define _POSIX_THREADS in unistd.h. Some apparently don't
2096 # (e.g. gnu pth with pthread emulation)
2097 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
2098 AC_EGREP_CPP(yes,
2099 [
2100 #include <unistd.h>
2101 #ifdef _POSIX_THREADS
2102 yes
2103 #endif
2104 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
2105 AC_MSG_RESULT($unistd_defines_pthreads)
2107 AC_DEFINE(_REENTRANT)
2108 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
2109 AC_DEFINE(C_THREADS)
2110 AC_DEFINE(HURD_C_THREADS, 1,
2111 [Define if you are using Mach cthreads directly under /include])
2112 LIBS="$LIBS -lthreads"
2113 THREADOBJ="Python/thread.o"],[
2114 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
2115 AC_DEFINE(C_THREADS)
2116 AC_DEFINE(MACH_C_THREADS, 1,
2117 [Define if you are using Mach cthreads under mach /])
2118 THREADOBJ="Python/thread.o"],[
2119 AC_MSG_CHECKING(for --with-pth)
2120 AC_ARG_WITH([pth],
2121 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
2122 [AC_MSG_RESULT($withval)
2123 AC_DEFINE([WITH_THREAD])
2124 AC_DEFINE([HAVE_PTH], 1,
2125 [Define if you have GNU PTH threads.])
2126 LIBS="-lpth $LIBS"
2127 THREADOBJ="Python/thread.o"],
2128 [AC_MSG_RESULT(no)
2130 # Just looking for pthread_create in libpthread is not enough:
2131 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
2132 # So we really have to include pthread.h, and then link.
2133 _libs=$LIBS
2134 LIBS="$LIBS -lpthread"
2135 AC_MSG_CHECKING([for pthread_create in -lpthread])
2136 AC_TRY_LINK([#include <pthread.h>
2138 void * start_routine (void *arg) { exit (0); }], [
2139 pthread_create (NULL, NULL, start_routine, NULL)], [
2140 AC_MSG_RESULT(yes)
2141 AC_DEFINE(WITH_THREAD)
2142 posix_threads=yes
2143 THREADOBJ="Python/thread.o"],[
2144 LIBS=$_libs
2145 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
2146 posix_threads=yes
2147 THREADOBJ="Python/thread.o"],[
2148 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
2149 AC_DEFINE(ATHEOS_THREADS, 1,
2150 [Define this if you have AtheOS threads.])
2151 THREADOBJ="Python/thread.o"],[
2152 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
2153 posix_threads=yes
2154 LIBS="$LIBS -lpthreads"
2155 THREADOBJ="Python/thread.o"], [
2156 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
2157 posix_threads=yes
2158 LIBS="$LIBS -lc_r"
2159 THREADOBJ="Python/thread.o"], [
2160 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
2161 posix_threads=yes
2162 LIBS="$LIBS -lpthread"
2163 THREADOBJ="Python/thread.o"], [
2164 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
2165 posix_threads=yes
2166 LIBS="$LIBS -lcma"
2167 THREADOBJ="Python/thread.o"],[
2168 USE_THREAD_MODULE="#"])
2169 ])])])])])])])])])
2171 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
2172 LIBS="$LIBS -lmpc"
2173 THREADOBJ="Python/thread.o"
2174 USE_THREAD_MODULE=""])
2176 if test "$posix_threads" != "yes"; then
2177 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
2178 LIBS="$LIBS -lthread"
2179 THREADOBJ="Python/thread.o"
2180 USE_THREAD_MODULE=""])
2181 fi
2183 if test "$USE_THREAD_MODULE" != "#"
2184 then
2185 # If the above checks didn't disable threads, (at least) OSF1
2186 # needs this '-threads' argument during linking.
2187 case $ac_sys_system in
2188 OSF1) LDLAST=-threads;;
2189 esac
2190 fi
2191 fi
2193 if test "$posix_threads" = "yes"; then
2194 if test "$unistd_defines_pthreads" = "no"; then
2195 AC_DEFINE(_POSIX_THREADS, 1,
2196 [Define if you have POSIX threads,
2197 and your system does not define that.])
2198 fi
2200 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
2201 case $ac_sys_system/$ac_sys_release in
2202 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
2203 Defined for Solaris 2.6 bug in pthread header.)
2204 ;;
2205 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2206 Define if the Posix semaphores do not work on your system)
2207 ;;
2208 AIX/5) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
2209 Define if the Posix semaphores do not work on your system)
2210 ;;
2211 esac
2213 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
2214 AC_CACHE_VAL(ac_cv_pthread_system_supported,
2215 [AC_TRY_RUN([#include <pthread.h>
2216 void *foo(void *parm) {
2217 return NULL;
2218 }
2219 main() {
2220 pthread_attr_t attr;
2221 pthread_t id;
2222 if (pthread_attr_init(&attr)) exit(-1);
2223 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
2224 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
2225 exit(0);
2226 }],
2227 ac_cv_pthread_system_supported=yes,
2228 ac_cv_pthread_system_supported=no,
2229 ac_cv_pthread_system_supported=no)
2230 ])
2231 AC_MSG_RESULT($ac_cv_pthread_system_supported)
2232 if test "$ac_cv_pthread_system_supported" = "yes"; then
2233 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2234 fi
2235 AC_CHECK_FUNCS(pthread_sigmask,
2236 [case $ac_sys_system in
2237 CYGWIN*)
2238 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2239 [Define if pthread_sigmask() does not work on your system.])
2240 ;;
2241 esac])
2242 fi
2245 # Check for enable-ipv6
2246 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2247 AC_MSG_CHECKING([if --enable-ipv6 is specified])
2248 AC_ARG_ENABLE(ipv6,
2249 [ --enable-ipv6 Enable ipv6 (with ipv4) support
2250 --disable-ipv6 Disable ipv6 support],
2251 [ case "$enableval" in
2252 no)
2253 AC_MSG_RESULT(no)
2254 ipv6=no
2255 ;;
2256 *) AC_MSG_RESULT(yes)
2257 AC_DEFINE(ENABLE_IPV6)
2258 ipv6=yes
2259 ;;
2260 esac ],
2262 [
2263 dnl the check does not work on cross compilation case...
2264 AC_TRY_RUN([ /* AF_INET6 available check */
2265 #include <sys/types.h>
2266 #include <sys/socket.h>
2267 main()
2268 {
2269 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2270 exit(1);
2271 else
2272 exit(0);
2273 }
2274 ],
2275 AC_MSG_RESULT(yes)
2276 ipv6=yes,
2277 AC_MSG_RESULT(no)
2278 ipv6=no,
2279 AC_MSG_RESULT(no)
2280 ipv6=no
2281 )
2283 if test "$ipv6" = "yes"; then
2284 AC_MSG_CHECKING(if RFC2553 API is available)
2285 AC_TRY_COMPILE([#include <sys/types.h>
2286 #include <netinet/in.h>],
2287 [struct sockaddr_in6 x;
2288 x.sin6_scope_id;],
2289 AC_MSG_RESULT(yes)
2290 ipv6=yes,
2291 AC_MSG_RESULT(no, IPv6 disabled)
2292 ipv6=no)
2293 fi
2295 if test "$ipv6" = "yes"; then
2296 AC_DEFINE(ENABLE_IPV6)
2297 fi
2298 ])
2300 ipv6type=unknown
2301 ipv6lib=none
2302 ipv6trylibc=no
2304 if test "$ipv6" = "yes"; then
2305 AC_MSG_CHECKING([ipv6 stack type])
2306 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2307 do
2308 case $i in
2309 inria)
2310 dnl http://www.kame.net/
2311 AC_EGREP_CPP(yes, [
2312 #include <netinet/in.h>
2313 #ifdef IPV6_INRIA_VERSION
2314 yes
2315 #endif],
2316 [ipv6type=$i])
2317 ;;
2318 kame)
2319 dnl http://www.kame.net/
2320 AC_EGREP_CPP(yes, [
2321 #include <netinet/in.h>
2322 #ifdef __KAME__
2323 yes
2324 #endif],
2325 [ipv6type=$i;
2326 ipv6lib=inet6
2327 ipv6libdir=/usr/local/v6/lib
2328 ipv6trylibc=yes])
2329 ;;
2330 linux-glibc)
2331 dnl http://www.v6.linux.or.jp/
2332 AC_EGREP_CPP(yes, [
2333 #include <features.h>
2334 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2335 yes
2336 #endif],
2337 [ipv6type=$i;
2338 ipv6trylibc=yes])
2339 ;;
2340 linux-inet6)
2341 dnl http://www.v6.linux.or.jp/
2342 if test -d /usr/inet6; then
2343 ipv6type=$i
2344 ipv6lib=inet6
2345 ipv6libdir=/usr/inet6/lib
2346 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2347 fi
2348 ;;
2349 solaris)
2350 if test -f /etc/netconfig; then
2351 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2352 ipv6type=$i
2353 ipv6trylibc=yes
2354 fi
2355 fi
2356 ;;
2357 toshiba)
2358 AC_EGREP_CPP(yes, [
2359 #include <sys/param.h>
2360 #ifdef _TOSHIBA_INET6
2361 yes
2362 #endif],
2363 [ipv6type=$i;
2364 ipv6lib=inet6;
2365 ipv6libdir=/usr/local/v6/lib])
2366 ;;
2367 v6d)
2368 AC_EGREP_CPP(yes, [
2369 #include </usr/local/v6/include/sys/v6config.h>
2370 #ifdef __V6D__
2371 yes
2372 #endif],
2373 [ipv6type=$i;
2374 ipv6lib=v6;
2375 ipv6libdir=/usr/local/v6/lib;
2376 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2377 ;;
2378 zeta)
2379 AC_EGREP_CPP(yes, [
2380 #include <sys/param.h>
2381 #ifdef _ZETA_MINAMI_INET6
2382 yes
2383 #endif],
2384 [ipv6type=$i;
2385 ipv6lib=inet6;
2386 ipv6libdir=/usr/local/v6/lib])
2387 ;;
2388 esac
2389 if test "$ipv6type" != "unknown"; then
2390 break
2391 fi
2392 done
2393 AC_MSG_RESULT($ipv6type)
2394 fi
2396 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2397 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2398 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2399 echo "using lib$ipv6lib"
2400 else
2401 if test $ipv6trylibc = "yes"; then
2402 echo "using libc"
2403 else
2404 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2405 echo "You need to fetch lib$ipv6lib.a from appropriate"
2406 echo 'ipv6 kit and compile beforehand.'
2407 exit 1
2408 fi
2409 fi
2410 fi
2412 AC_MSG_CHECKING(for OSX 10.5 SDK or later)
2413 AC_TRY_COMPILE([#include <Carbon/Carbon.h>], FSIORefNum fRef = 0,
2414 AC_DEFINE(HAVE_OSX105_SDK, 1, Define if compiling using MacOS X 10.5 SDK or later.)
2415 AC_MSG_RESULT(yes),
2416 AC_MSG_RESULT(no)
2417 )
2419 # Check for --with-doc-strings
2420 AC_MSG_CHECKING(for --with-doc-strings)
2421 AC_ARG_WITH(doc-strings,
2422 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2424 if test -z "$with_doc_strings"
2425 then with_doc_strings="yes"
2426 fi
2427 if test "$with_doc_strings" != "no"
2428 then
2429 AC_DEFINE(WITH_DOC_STRINGS, 1,
2430 [Define if you want documentation strings in extension modules])
2431 fi
2432 AC_MSG_RESULT($with_doc_strings)
2434 # Check for Python-specific malloc support
2435 AC_MSG_CHECKING(for --with-tsc)
2436 AC_ARG_WITH(tsc,
2437 [ --with(out)-tsc enable/disable timestamp counter profile], [
2438 if test "$withval" != no
2439 then
2440 AC_DEFINE(WITH_TSC, 1,
2441 [Define to profile with the Pentium timestamp counter])
2442 AC_MSG_RESULT(yes)
2443 else AC_MSG_RESULT(no)
2444 fi],
2445 [AC_MSG_RESULT(no)])
2447 # Check for Python-specific malloc support
2448 AC_MSG_CHECKING(for --with-pymalloc)
2449 AC_ARG_WITH(pymalloc,
2450 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2452 if test -z "$with_pymalloc"
2453 then with_pymalloc="yes"
2454 fi
2455 if test "$with_pymalloc" != "no"
2456 then
2457 AC_DEFINE(WITH_PYMALLOC, 1,
2458 [Define if you want to compile in Python-specific mallocs])
2459 fi
2460 AC_MSG_RESULT($with_pymalloc)
2462 # Check for --with-wctype-functions
2463 AC_MSG_CHECKING(for --with-wctype-functions)
2464 AC_ARG_WITH(wctype-functions,
2465 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2466 [
2467 if test "$withval" != no
2468 then
2469 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2470 [Define if you want wctype.h functions to be used instead of the
2471 one supplied by Python itself. (see Include/unicodectype.h).])
2472 AC_MSG_RESULT(yes)
2473 else AC_MSG_RESULT(no)
2474 fi],
2475 [AC_MSG_RESULT(no)])
2477 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2478 AC_SUBST(DLINCLDIR)
2479 DLINCLDIR=.
2481 # the dlopen() function means we might want to use dynload_shlib.o. some
2482 # platforms, such as AIX, have dlopen(), but don't want to use it.
2483 AC_CHECK_FUNCS(dlopen)
2485 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2486 # loading of modules.
2487 AC_SUBST(DYNLOADFILE)
2488 AC_MSG_CHECKING(DYNLOADFILE)
2489 if test -z "$DYNLOADFILE"
2490 then
2491 case $ac_sys_system/$ac_sys_release in
2492 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2493 if test "$ac_cv_func_dlopen" = yes
2494 then DYNLOADFILE="dynload_shlib.o"
2495 else DYNLOADFILE="dynload_aix.o"
2496 fi
2497 ;;
2498 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2499 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2500 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2501 atheos*) DYNLOADFILE="dynload_atheos.o";;
2502 *)
2503 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2504 # out any dynamic loading
2505 if test "$ac_cv_func_dlopen" = yes
2506 then DYNLOADFILE="dynload_shlib.o"
2507 else DYNLOADFILE="dynload_stub.o"
2508 fi
2509 ;;
2510 esac
2511 fi
2512 AC_MSG_RESULT($DYNLOADFILE)
2513 if test "$DYNLOADFILE" != "dynload_stub.o"
2514 then
2515 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2516 [Defined when any dynamic module loading is enabled.])
2517 fi
2519 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2521 AC_SUBST(MACHDEP_OBJS)
2522 AC_MSG_CHECKING(MACHDEP_OBJS)
2523 if test -z "$MACHDEP_OBJS"
2524 then
2525 MACHDEP_OBJS=$extra_machdep_objs
2526 else
2527 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2528 fi
2529 AC_MSG_RESULT(MACHDEP_OBJS)
2531 # checks for library functions
2532 AC_CHECK_FUNCS(alarm setitimer getitimer bind_textdomain_codeset chown \
2533 clock confstr ctermid execv fchmod fchown fork fpathconf ftime ftruncate \
2534 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2535 getpriority getpwent getspnam getspent getsid getwd \
2536 kill killpg lchmod lchown lstat mbrtowc mkfifo mknod mktime \
2537 mremap nice pathconf pause plock poll pthread_init \
2538 putenv readlink realpath \
2539 select sem_open sem_timedwait sem_getvalue sem_unlink setegid seteuid \
2540 setgid \
2541 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2542 sigaction siginterrupt sigrelse strftime strlcpy \
2543 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2544 truncate uname unsetenv utimes waitpid wait3 wait4 \
2545 wcscoll wcsftime wcsxfrm _getpty)
2547 # For some functions, having a definition is not sufficient, since
2548 # we want to take their address.
2549 AC_MSG_CHECKING(for chroot)
2550 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2551 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2552 AC_MSG_RESULT(yes),
2553 AC_MSG_RESULT(no)
2554 )
2555 AC_MSG_CHECKING(for link)
2556 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2557 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2558 AC_MSG_RESULT(yes),
2559 AC_MSG_RESULT(no)
2560 )
2561 AC_MSG_CHECKING(for symlink)
2562 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2563 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2564 AC_MSG_RESULT(yes),
2565 AC_MSG_RESULT(no)
2566 )
2567 AC_MSG_CHECKING(for fchdir)
2568 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2569 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2570 AC_MSG_RESULT(yes),
2571 AC_MSG_RESULT(no)
2572 )
2573 AC_MSG_CHECKING(for fsync)
2574 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2575 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2576 AC_MSG_RESULT(yes),
2577 AC_MSG_RESULT(no)
2578 )
2579 AC_MSG_CHECKING(for fdatasync)
2580 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2581 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2582 AC_MSG_RESULT(yes),
2583 AC_MSG_RESULT(no)
2584 )
2585 AC_MSG_CHECKING(for epoll)
2586 AC_TRY_COMPILE([#include <sys/epoll.h>], void *x=epoll_create,
2587 AC_DEFINE(HAVE_EPOLL, 1, Define if you have the 'epoll' functions.)
2588 AC_MSG_RESULT(yes),
2589 AC_MSG_RESULT(no)
2590 )
2591 AC_MSG_CHECKING(for kqueue)
2592 AC_TRY_COMPILE([
2593 #include <sys/types.h>
2594 #include <sys/event.h>
2595 ], int x=kqueue(),
2596 AC_DEFINE(HAVE_KQUEUE, 1, Define if you have the 'kqueue' functions.)
2597 AC_MSG_RESULT(yes),
2598 AC_MSG_RESULT(no)
2599 )
2600 # On some systems (eg. FreeBSD 5), we would find a definition of the
2601 # functions ctermid_r, setgroups in the library, but no prototype
2602 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2603 # address to avoid compiler warnings and potential miscompilations
2604 # because of the missing prototypes.
2606 AC_MSG_CHECKING(for ctermid_r)
2607 AC_TRY_COMPILE([
2608 #include "confdefs.h"
2609 #include <stdio.h>
2610 ], void* p = ctermid_r,
2611 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2612 AC_MSG_RESULT(yes),
2613 AC_MSG_RESULT(no)
2614 )
2616 AC_MSG_CHECKING(for flock)
2617 AC_TRY_COMPILE([
2618 #include "confdefs.h"
2619 #include <sys/file.h>
2620 ], void* p = flock,
2621 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2622 AC_MSG_RESULT(yes),
2623 AC_MSG_RESULT(no)
2624 )
2626 AC_MSG_CHECKING(for getpagesize)
2627 AC_TRY_COMPILE([
2628 #include "confdefs.h"
2629 #include <unistd.h>
2630 ], void* p = getpagesize,
2631 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2632 AC_MSG_RESULT(yes),
2633 AC_MSG_RESULT(no)
2634 )
2636 dnl check for true
2637 AC_CHECK_PROGS(TRUE, true, /bin/true)
2639 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2640 dnl On others, they are in the C library, so we to take no action
2641 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2642 AC_CHECK_LIB(resolv, inet_aton)
2643 )
2645 # On Tru64, chflags seems to be present, but calling it will
2646 # exit Python
2647 AC_CACHE_CHECK([for chflags], [ac_cv_have_chflags], [dnl
2648 AC_TRY_RUN([[
2649 #include <sys/stat.h>
2650 #include <unistd.h>
2651 int main(int argc, char*argv[])
2652 {
2653 if(chflags(argv[0], 0) != 0)
2654 return 1;
2655 return 0;
2656 }
2657 ]], ac_cv_have_chflags=yes,
2658 ac_cv_have_chflags=no,
2659 ac_cv_have_chflags=cross)
2660 ])
2661 if test "$ac_cv_have_chflags" = cross ; then
2662 AC_CHECK_FUNC([chflags], [ac_cv_have_chflags="yes"], [ac_cv_have_chflags="no"])
2663 fi
2664 if test "$ac_cv_have_chflags" = yes ; then
2665 AC_DEFINE(HAVE_CHFLAGS, 1, Define to 1 if you have the `chflags' function.)
2666 fi
2668 AC_CACHE_CHECK([for lchflags], [ac_cv_have_lchflags], [dnl
2669 AC_TRY_RUN([[
2670 #include <sys/stat.h>
2671 #include <unistd.h>
2672 int main(int argc, char*argv[])
2673 {
2674 if(lchflags(argv[0], 0) != 0)
2675 return 1;
2676 return 0;
2677 }
2678 ]], ac_cv_have_lchflags=yes,
2679 ac_cv_have_lchflags=no,
2680 ac_cv_have_lchflags=cross)
2681 ])
2682 if test "$ac_cv_have_lchflags" = cross ; then
2683 AC_CHECK_FUNC([lchflags], [ac_cv_have_lchflags="yes"], [ac_cv_have_lchflags="no"])
2684 fi
2685 if test "$ac_cv_have_lchflags" = yes ; then
2686 AC_DEFINE(HAVE_LCHFLAGS, 1, Define to 1 if you have the `lchflags' function.)
2687 fi
2689 dnl Check if system zlib has *Copy() functions
2690 dnl
2691 dnl On MacOSX the linker will search for dylibs on the entire linker path
2692 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2693 dnl to revert to a more traditional unix behaviour and make it possible to
2694 dnl override the system libz with a local static library of libz. Temporarily
2695 dnl add that flag to our CFLAGS as well to ensure that we check the version
2696 dnl of libz that will be used by setup.py.
2697 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2698 dnl environment as setup.py (and leaving it out can cause configure to use the
2699 dnl wrong version of the library)
2700 case $ac_sys_system/$ac_sys_release in
2701 Darwin/*)
2702 _CUR_CFLAGS="${CFLAGS}"
2703 _CUR_LDFLAGS="${LDFLAGS}"
2704 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2705 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2706 ;;
2707 esac
2709 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2711 case $ac_sys_system/$ac_sys_release in
2712 Darwin/*)
2713 CFLAGS="${_CUR_CFLAGS}"
2714 LDFLAGS="${_CUR_LDFLAGS}"
2715 ;;
2716 esac
2718 AC_MSG_CHECKING(for hstrerror)
2719 AC_TRY_LINK([
2720 #include "confdefs.h"
2721 #include <netdb.h>
2722 ], void* p = hstrerror; hstrerror(0),
2723 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2724 AC_MSG_RESULT(yes),
2725 AC_MSG_RESULT(no)
2726 )
2728 AC_MSG_CHECKING(for inet_aton)
2729 AC_TRY_LINK([
2730 #include "confdefs.h"
2731 #include <sys/types.h>
2732 #include <sys/socket.h>
2733 #include <netinet/in.h>
2734 #include <arpa/inet.h>
2735 ], void* p = inet_aton;inet_aton(0,0),
2736 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2737 AC_MSG_RESULT(yes),
2738 AC_MSG_RESULT(no)
2739 )
2741 AC_MSG_CHECKING(for inet_pton)
2742 AC_TRY_COMPILE([
2743 #include "confdefs.h"
2744 #include <sys/types.h>
2745 #include <sys/socket.h>
2746 #include <netinet/in.h>
2747 #include <arpa/inet.h>
2748 ], void* p = inet_pton,
2749 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2750 AC_MSG_RESULT(yes),
2751 AC_MSG_RESULT(no)
2752 )
2754 # On some systems, setgroups is in unistd.h, on others, in grp.h
2755 AC_MSG_CHECKING(for setgroups)
2756 AC_TRY_COMPILE([
2757 #include "confdefs.h"
2758 #include <unistd.h>
2759 #ifdef HAVE_GRP_H
2760 #include <grp.h>
2761 #endif
2762 ],
2763 void* p = setgroups,
2764 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2765 AC_MSG_RESULT(yes),
2766 AC_MSG_RESULT(no)
2767 )
2769 # check for openpty and forkpty
2771 AC_CHECK_FUNCS(openpty,,
2772 AC_CHECK_LIB(util,openpty,
2773 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2774 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2775 )
2776 )
2777 AC_CHECK_FUNCS(forkpty,,
2778 AC_CHECK_LIB(util,forkpty,
2779 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2780 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2781 )
2782 )
2784 # Stuff for expat.
2785 AC_CHECK_FUNCS(memmove)
2787 # check for long file support functions
2788 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2790 AC_REPLACE_FUNCS(dup2 getcwd strdup)
2791 AC_CHECK_FUNCS(getpgrp,
2792 AC_TRY_COMPILE([#include <unistd.h>],
2793 [getpgrp(0);],
2794 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2795 [Define if getpgrp() must be called as getpgrp(0).])
2796 )
2797 )
2798 AC_CHECK_FUNCS(setpgrp,
2799 AC_TRY_COMPILE([#include <unistd.h>],
2800 [setpgrp(0,0);],
2801 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2802 [Define if setpgrp() must be called as setpgrp(0, 0).])
2803 )
2804 )
2805 AC_CHECK_FUNCS(gettimeofday,
2806 AC_TRY_COMPILE([#include <sys/time.h>],
2807 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2808 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2809 [Define if gettimeofday() does not have second (timezone) argument
2810 This is the case on Motorola V4 (R40V4.2)])
2811 )
2812 )
2814 AC_MSG_CHECKING(for major, minor, and makedev)
2815 AC_TRY_LINK([
2816 #if defined(MAJOR_IN_MKDEV)
2817 #include <sys/mkdev.h>
2818 #elif defined(MAJOR_IN_SYSMACROS)
2819 #include <sys/sysmacros.h>
2820 #else
2821 #include <sys/types.h>
2822 #endif
2823 ],[
2824 makedev(major(0),minor(0));
2825 ],[
2826 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2827 [Define to 1 if you have the device macros.])
2828 AC_MSG_RESULT(yes)
2829 ],[
2830 AC_MSG_RESULT(no)
2831 ])
2833 # On OSF/1 V5.1, getaddrinfo is available, but a define
2834 # for [no]getaddrinfo in netdb.h.
2835 AC_MSG_CHECKING(for getaddrinfo)
2836 AC_TRY_LINK([
2837 #include <sys/types.h>
2838 #include <sys/socket.h>
2839 #include <netdb.h>
2840 #include <stdio.h>
2841 ],[
2842 getaddrinfo(NULL, NULL, NULL, NULL);
2843 ], [
2844 AC_MSG_RESULT(yes)
2845 AC_MSG_CHECKING(getaddrinfo bug)
2846 AC_TRY_RUN([
2847 #include <sys/types.h>
2848 #include <netdb.h>
2849 #include <string.h>
2850 #include <sys/socket.h>
2851 #include <netinet/in.h>
2853 main()
2854 {
2855 int passive, gaierr, inet4 = 0, inet6 = 0;
2856 struct addrinfo hints, *ai, *aitop;
2857 char straddr[INET6_ADDRSTRLEN], strport[16];
2859 for (passive = 0; passive <= 1; passive++) {
2860 memset(&hints, 0, sizeof(hints));
2861 hints.ai_family = AF_UNSPEC;
2862 hints.ai_flags = passive ? AI_PASSIVE : 0;
2863 hints.ai_socktype = SOCK_STREAM;
2864 hints.ai_protocol = IPPROTO_TCP;
2865 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2866 (void)gai_strerror(gaierr);
2867 goto bad;
2868 }
2869 for (ai = aitop; ai; ai = ai->ai_next) {
2870 if (ai->ai_addr == NULL ||
2871 ai->ai_addrlen == 0 ||
2872 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2873 straddr, sizeof(straddr), strport, sizeof(strport),
2874 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2875 goto bad;
2876 }
2877 switch (ai->ai_family) {
2878 case AF_INET:
2879 if (strcmp(strport, "54321") != 0) {
2880 goto bad;
2881 }
2882 if (passive) {
2883 if (strcmp(straddr, "0.0.0.0") != 0) {
2884 goto bad;
2885 }
2886 } else {
2887 if (strcmp(straddr, "127.0.0.1") != 0) {
2888 goto bad;
2889 }
2890 }
2891 inet4++;
2892 break;
2893 case AF_INET6:
2894 if (strcmp(strport, "54321") != 0) {
2895 goto bad;
2896 }
2897 if (passive) {
2898 if (strcmp(straddr, "::") != 0) {
2899 goto bad;
2900 }
2901 } else {
2902 if (strcmp(straddr, "::1") != 0) {
2903 goto bad;
2904 }
2905 }
2906 inet6++;
2907 break;
2908 case AF_UNSPEC:
2909 goto bad;
2910 break;
2911 default:
2912 /* another family support? */
2913 break;
2914 }
2915 }
2916 }
2918 if (!(inet4 == 0 || inet4 == 2))
2919 goto bad;
2920 if (!(inet6 == 0 || inet6 == 2))
2921 goto bad;
2923 if (aitop)
2924 freeaddrinfo(aitop);
2925 exit(0);
2927 bad:
2928 if (aitop)
2929 freeaddrinfo(aitop);
2930 exit(1);
2931 }
2932 ],
2933 AC_MSG_RESULT(good)
2934 buggygetaddrinfo=no,
2935 AC_MSG_RESULT(buggy)
2936 buggygetaddrinfo=yes,
2937 AC_MSG_RESULT(buggy)
2938 buggygetaddrinfo=yes)], [
2939 AC_MSG_RESULT(no)
2940 buggygetaddrinfo=yes
2941 ])
2943 if test "$buggygetaddrinfo" = "yes"; then
2944 if test "$ipv6" = "yes"; then
2945 echo 'Fatal: You must get working getaddrinfo() function.'
2946 echo ' or you can specify "--disable-ipv6"'.
2947 exit 1
2948 fi
2949 else
2950 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2951 fi
2952 AC_CHECK_FUNCS(getnameinfo)
2954 # checks for structures
2955 AC_HEADER_TIME
2956 AC_STRUCT_TM
2957 AC_STRUCT_TIMEZONE
2958 AC_CHECK_MEMBERS([struct stat.st_rdev])
2959 AC_CHECK_MEMBERS([struct stat.st_blksize])
2960 AC_CHECK_MEMBERS([struct stat.st_flags])
2961 AC_CHECK_MEMBERS([struct stat.st_gen])
2962 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2963 AC_STRUCT_ST_BLOCKS
2965 AC_MSG_CHECKING(for time.h that defines altzone)
2966 AC_CACHE_VAL(ac_cv_header_time_altzone,
2967 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2968 ac_cv_header_time_altzone=yes,
2969 ac_cv_header_time_altzone=no)])
2970 AC_MSG_RESULT($ac_cv_header_time_altzone)
2971 if test $ac_cv_header_time_altzone = yes; then
2972 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2973 fi
2975 was_it_defined=no
2976 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2977 AC_TRY_COMPILE([
2978 #include <sys/types.h>
2979 #include <sys/select.h>
2980 #include <sys/time.h>
2981 ], [;], [
2982 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2983 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2984 (which you can't on SCO ODT 3.0).])
2985 was_it_defined=yes
2986 ])
2987 AC_MSG_RESULT($was_it_defined)
2989 AC_MSG_CHECKING(for addrinfo)
2990 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2991 AC_TRY_COMPILE([
2992 # include <netdb.h>],
2993 [struct addrinfo a],
2994 ac_cv_struct_addrinfo=yes,
2995 ac_cv_struct_addrinfo=no))
2996 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2997 if test $ac_cv_struct_addrinfo = yes; then
2998 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2999 fi
3001 AC_MSG_CHECKING(for sockaddr_storage)
3002 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
3003 AC_TRY_COMPILE([
3004 # include <sys/types.h>
3005 # include <sys/socket.h>],
3006 [struct sockaddr_storage s],
3007 ac_cv_struct_sockaddr_storage=yes,
3008 ac_cv_struct_sockaddr_storage=no))
3009 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
3010 if test $ac_cv_struct_sockaddr_storage = yes; then
3011 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
3012 fi
3014 # checks for compiler characteristics
3016 AC_C_CHAR_UNSIGNED
3017 AC_C_CONST
3019 works=no
3020 AC_MSG_CHECKING(for working volatile)
3021 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
3022 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
3023 )
3024 AC_MSG_RESULT($works)
3026 works=no
3027 AC_MSG_CHECKING(for working signed char)
3028 AC_TRY_COMPILE([], [signed char c;], works=yes,
3029 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
3030 )
3031 AC_MSG_RESULT($works)
3033 have_prototypes=no
3034 AC_MSG_CHECKING(for prototypes)
3035 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
3036 AC_DEFINE(HAVE_PROTOTYPES, 1,
3037 [Define if your compiler supports function prototype])
3038 have_prototypes=yes
3039 ])
3040 AC_MSG_RESULT($have_prototypes)
3042 works=no
3043 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
3044 AC_TRY_COMPILE([
3045 #include <stdarg.h>
3046 int foo(int x, ...) {
3047 va_list va;
3048 va_start(va, x);
3049 va_arg(va, int);
3050 va_arg(va, char *);
3051 va_arg(va, double);
3052 return 0;
3053 }
3054 ], [return foo(10, "", 3.14);], [
3055 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
3056 [Define if your compiler supports variable length function prototypes
3057 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
3058 works=yes
3059 ])
3060 AC_MSG_RESULT($works)
3062 # check for socketpair
3063 AC_MSG_CHECKING(for socketpair)
3064 AC_TRY_COMPILE([
3065 #include <sys/types.h>
3066 #include <sys/socket.h>
3067 ], void *x=socketpair,
3068 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
3069 AC_MSG_RESULT(yes),
3070 AC_MSG_RESULT(no)
3071 )
3073 # check if sockaddr has sa_len member
3074 AC_MSG_CHECKING(if sockaddr has sa_len member)
3075 AC_TRY_COMPILE([#include <sys/types.h>
3076 #include <sys/socket.h>],
3077 [struct sockaddr x;
3078 x.sa_len = 0;],
3079 AC_MSG_RESULT(yes)
3080 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
3081 AC_MSG_RESULT(no))
3083 va_list_is_array=no
3084 AC_MSG_CHECKING(whether va_list is an array)
3085 AC_TRY_COMPILE([
3086 #ifdef HAVE_STDARG_PROTOTYPES
3087 #include <stdarg.h>
3088 #else
3089 #include <varargs.h>
3090 #endif
3091 ], [va_list list1, list2; list1 = list2;], , [
3092 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
3093 va_list_is_array=yes
3094 ])
3095 AC_MSG_RESULT($va_list_is_array)
3097 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
3098 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
3099 [Define this if you have some version of gethostbyname_r()])
3101 AC_CHECK_FUNC(gethostbyname_r, [
3102 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3103 AC_MSG_CHECKING([gethostbyname_r with 6 args])
3104 OLD_CFLAGS=$CFLAGS
3105 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
3106 AC_TRY_COMPILE([
3107 # include <netdb.h>
3108 ], [
3109 char *name;
3110 struct hostent *he, *res;
3111 char buffer[2048];
3112 int buflen = 2048;
3113 int h_errnop;
3115 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
3116 ], [
3117 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3118 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
3119 [Define this if you have the 6-arg version of gethostbyname_r().])
3120 AC_MSG_RESULT(yes)
3121 ], [
3122 AC_MSG_RESULT(no)
3123 AC_MSG_CHECKING([gethostbyname_r with 5 args])
3124 AC_TRY_COMPILE([
3125 # include <netdb.h>
3126 ], [
3127 char *name;
3128 struct hostent *he;
3129 char buffer[2048];
3130 int buflen = 2048;
3131 int h_errnop;
3133 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
3134 ], [
3135 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3136 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
3137 [Define this if you have the 5-arg version of gethostbyname_r().])
3138 AC_MSG_RESULT(yes)
3139 ], [
3140 AC_MSG_RESULT(no)
3141 AC_MSG_CHECKING([gethostbyname_r with 3 args])
3142 AC_TRY_COMPILE([
3143 # include <netdb.h>
3144 ], [
3145 char *name;
3146 struct hostent *he;
3147 struct hostent_data data;
3149 (void) gethostbyname_r(name, he, &data);
3150 ], [
3151 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
3152 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
3153 [Define this if you have the 3-arg version of gethostbyname_r().])
3154 AC_MSG_RESULT(yes)
3155 ], [
3156 AC_MSG_RESULT(no)
3157 ])
3158 ])
3159 ])
3160 CFLAGS=$OLD_CFLAGS
3161 ], [
3162 AC_CHECK_FUNCS(gethostbyname)
3163 ])
3164 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
3165 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
3166 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
3167 AC_SUBST(HAVE_GETHOSTBYNAME_R)
3168 AC_SUBST(HAVE_GETHOSTBYNAME)
3170 # checks for system services
3171 # (none yet)
3173 # Linux requires this for correct f.p. operations
3174 AC_CHECK_FUNC(__fpu_control,
3175 [],
3176 [AC_CHECK_LIB(ieee, __fpu_control)
3177 ])
3179 # Check for --with-fpectl
3180 AC_MSG_CHECKING(for --with-fpectl)
3181 AC_ARG_WITH(fpectl,
3182 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
3183 [
3184 if test "$withval" != no
3185 then
3186 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
3187 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
3188 AC_MSG_RESULT(yes)
3189 else AC_MSG_RESULT(no)
3190 fi],
3191 [AC_MSG_RESULT(no)])
3193 # check for --with-libm=...
3194 AC_SUBST(LIBM)
3195 case $ac_sys_system in
3196 Darwin) ;;
3197 *) LIBM=-lm
3198 esac
3199 AC_MSG_CHECKING(for --with-libm=STRING)
3200 AC_ARG_WITH(libm,
3201 AC_HELP_STRING(--with-libm=STRING, math library),
3202 [
3203 if test "$withval" = no
3204 then LIBM=
3205 AC_MSG_RESULT(force LIBM empty)
3206 elif test "$withval" != yes
3207 then LIBM=$withval
3208 AC_MSG_RESULT(set LIBM="$withval")
3209 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
3210 fi],
3211 [AC_MSG_RESULT(default LIBM="$LIBM")])
3213 # check for --with-libc=...
3214 AC_SUBST(LIBC)
3215 AC_MSG_CHECKING(for --with-libc=STRING)
3216 AC_ARG_WITH(libc,
3217 AC_HELP_STRING(--with-libc=STRING, C library),
3218 [
3219 if test "$withval" = no
3220 then LIBC=
3221 AC_MSG_RESULT(force LIBC empty)
3222 elif test "$withval" != yes
3223 then LIBC=$withval
3224 AC_MSG_RESULT(set LIBC="$withval")
3225 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
3226 fi],
3227 [AC_MSG_RESULT(default LIBC="$LIBC")])
3229 # **************************************************
3230 # * Check for various properties of floating point *
3231 # **************************************************
3233 AC_MSG_CHECKING(whether C doubles are little-endian IEEE 754 binary64)
3234 AC_CACHE_VAL(ac_cv_little_endian_double, [
3235 AC_TRY_RUN([
3236 #include <string.h>
3237 int main() {
3238 double x = 9006104071832581.0;
3239 if (memcmp(&x, "\x05\x04\x03\x02\x01\xff\x3f\x43", 8) == 0)
3240 return 0;
3241 else
3242 return 1;
3243 }
3244 ],
3245 ac_cv_little_endian_double=yes,
3246 ac_cv_little_endian_double=no,
3247 ac_cv_little_endian_double=no)])
3248 AC_MSG_RESULT($ac_cv_little_endian_double)
3249 if test "$ac_cv_little_endian_double" = yes
3250 then
3251 AC_DEFINE(DOUBLE_IS_LITTLE_ENDIAN_IEEE754, 1,
3252 [Define if C doubles are 64-bit IEEE 754 binary format, stored
3253 with the least significant byte first])
3254 fi
3256 AC_MSG_CHECKING(whether C doubles are big-endian IEEE 754 binary64)
3257 AC_CACHE_VAL(ac_cv_big_endian_double, [
3258 AC_TRY_RUN([
3259 #include <string.h>
3260 int main() {
3261 double x = 9006104071832581.0;
3262 if (memcmp(&x, "\x43\x3f\xff\x01\x02\x03\x04\x05", 8) == 0)
3263 return 0;
3264 else
3265 return 1;
3266 }
3267 ],
3268 ac_cv_big_endian_double=yes,
3269 ac_cv_big_endian_double=no,
3270 ac_cv_big_endian_double=no)])
3271 AC_MSG_RESULT($ac_cv_big_endian_double)
3272 if test "$ac_cv_big_endian_double" = yes
3273 then
3274 AC_DEFINE(DOUBLE_IS_BIG_ENDIAN_IEEE754, 1,
3275 [Define if C doubles are 64-bit IEEE 754 binary format, stored
3276 with the most significant byte first])
3277 fi
3279 # Some ARM platforms use a mixed-endian representation for doubles.
3280 # While Python doesn't currently have full support for these platforms
3281 # (see e.g., issue 1762561), we can at least make sure that float <-> string
3282 # conversions work.
3283 AC_MSG_CHECKING(whether C doubles are ARM mixed-endian IEEE 754 binary64)
3284 AC_CACHE_VAL(ac_cv_mixed_endian_double, [
3285 AC_TRY_RUN([
3286 #include <string.h>
3287 int main() {
3288 double x = 9006104071832581.0;
3289 if (memcmp(&x, "\x01\xff\x3f\x43\x05\x04\x03\x02", 8) == 0)
3290 return 0;
3291 else
3292 return 1;
3293 }
3294 ],
3295 ac_cv_mixed_endian_double=yes,
3296 ac_cv_mixed_endian_double=no,
3297 ac_cv_mixed_endian_double=no)])
3298 AC_MSG_RESULT($ac_cv_mixed_endian_double)
3299 if test "$ac_cv_mixed_endian_double" = yes
3300 then
3301 AC_DEFINE(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754, 1,
3302 [Define if C doubles are 64-bit IEEE 754 binary format, stored
3303 in ARM mixed-endian order (byte order 45670123)])
3304 fi
3306 # The short float repr introduced in Python 3.1 requires the
3307 # correctly-rounded string <-> double conversion functions from
3308 # Python/dtoa.c, which in turn require that the FPU uses 53-bit
3309 # rounding; this is a problem on x86, where the x87 FPU has a default
3310 # rounding precision of 64 bits. For gcc/x86, we try to fix this by
3311 # using inline assembler to get and set the x87 FPU control word.
3312 if test "$GCC" = yes && test -n "`$CC -dM -E - </dev/null | grep i386`"
3313 then
3314 # Check that it's okay to use gcc inline assembler to get and set
3315 # x87 control word. It should be, but you never know...
3316 AC_MSG_CHECKING(whether we can use gcc inline assembler to get and set x87 control word)
3317 AC_TRY_COMPILE([], [
3318 unsigned short cw;
3319 __asm__ __volatile__ ("fnstcw %0" : "=m" (cw));
3320 __asm__ __volatile__ ("fldcw %0" : : "m" (cw));
3321 ],
3322 [have_gcc_asm_for_x87=yes], [have_gcc_asm_for_x87=no])
3323 AC_MSG_RESULT($have_gcc_asm_for_x87)
3324 if test "$have_gcc_asm_for_x87" = yes
3325 then
3326 AC_DEFINE(HAVE_GCC_ASM_FOR_X87, 1,
3327 [Define if we can use gcc inline assembler to get and set x87 control word])
3328 fi
3329 fi
3331 # Detect whether system arithmetic is subject to x87-style double
3332 # rounding issues. The result of this test has little meaning on non
3333 # IEEE 754 platforms. On IEEE 754, test should return 1 if rounding
3334 # mode is round-to-nearest and double rounding issues are present, and
3335 # 0 otherwise. See http://bugs.python.org/issue2937 for more info.
3336 AC_MSG_CHECKING(for x87-style double rounding)
3337 # $BASECFLAGS may affect the result
3338 ac_save_cc="$CC"
3339 CC="$CC $BASECFLAGS"
3340 AC_TRY_RUN([
3341 #include <stdlib.h>
3342 #include <math.h>
3343 int main() {
3344 volatile double x, y, z;
3345 /* 1./(1-2**-53) -> 1+2**-52 (correct), 1.0 (double rounding) */
3346 x = 0.99999999999999989; /* 1-2**-53 */
3347 y = 1./x;
3348 if (y != 1.)
3349 exit(0);
3350 /* 1e16+2.99999 -> 1e16+2. (correct), 1e16+4. (double rounding) */
3351 x = 1e16;
3352 y = 2.99999;
3353 z = x + y;
3354 if (z != 1e16+4.)
3355 exit(0);
3356 /* both tests show evidence of double rounding */
3357 exit(1);
3358 }
3359 ],
3360 ac_cv_x87_double_rounding=no,
3361 ac_cv_x87_double_rounding=yes,
3362 ac_cv_x87_double_rounding=no)
3363 CC="$ac_save_cc"
3364 AC_MSG_RESULT($ac_cv_x87_double_rounding)
3365 if test "$ac_cv_x87_double_rounding" = yes
3366 then
3367 AC_DEFINE(X87_DOUBLE_ROUNDING, 1,
3368 [Define if arithmetic is subject to x87-style double rounding issue])
3369 fi
3371 # ************************************
3372 # * Check for mathematical functions *
3373 # ************************************
3375 LIBS_SAVE=$LIBS
3376 LIBS="$LIBS $LIBM"
3378 # On FreeBSD 6.2, it appears that tanh(-0.) returns 0. instead of
3379 # -0. on some architectures.
3380 AC_MSG_CHECKING(whether tanh preserves the sign of zero)
3381 AC_CACHE_VAL(ac_cv_tanh_preserves_zero_sign, [
3382 AC_TRY_RUN([
3383 #include <math.h>
3384 #include <stdlib.h>
3385 int main() {
3386 /* return 0 if either negative zeros don't exist
3387 on this platform or if negative zeros exist
3388 and tanh(-0.) == -0. */
3389 if (atan2(0., -1.) == atan2(-0., -1.) ||
3390 atan2(tanh(-0.), -1.) == atan2(-0., -1.)) exit(0);
3391 else exit(1);
3392 }
3393 ],
3394 ac_cv_tanh_preserves_zero_sign=yes,
3395 ac_cv_tanh_preserves_zero_sign=no,
3396 ac_cv_tanh_preserves_zero_sign=no)])
3397 AC_MSG_RESULT($ac_cv_tanh_preserves_zero_sign)
3398 if test "$ac_cv_tanh_preserves_zero_sign" = yes
3399 then
3400 AC_DEFINE(TANH_PRESERVES_ZERO_SIGN, 1,
3401 [Define if tanh(-0.) is -0., or if platform doesn't have signed zeros])
3402 fi
3404 AC_CHECK_FUNCS([acosh asinh atanh copysign expm1 finite hypot log1p round])
3405 AC_CHECK_DECLS([isinf, isnan, isfinite], [], [], [[#include <math.h>]])
3407 LIBS=$LIBS_SAVE
3409 # For multiprocessing module, check that sem_open
3410 # actually works. For FreeBSD versions <= 7.2,
3411 # the kernel module that provides POSIX semaphores
3412 # isn't loaded by default, so an attempt to call
3413 # sem_open results in a 'Signal 12' error.
3414 AC_MSG_CHECKING(whether POSIX semaphores are enabled)
3415 AC_CACHE_VAL(ac_cv_posix_semaphores_enabled,
3416 AC_TRY_RUN([
3417 #include <unistd.h>
3418 #include <fcntl.h>
3419 #include <stdio.h>
3420 #include <semaphore.h>
3421 #include <sys/stat.h>
3423 int main(void) {
3424 sem_t *a = sem_open("/autoconf", O_CREAT, S_IRUSR|S_IWUSR, 0);
3425 if (a == SEM_FAILED) {
3426 perror("sem_open");
3427 return 1;
3428 }
3429 sem_close(a);
3430 sem_unlink("/autoconf");
3431 return 0;
3432 }
3433 ], ac_cv_posix_semaphores_enabled=yes,
3434 ac_cv_posix_semaphores_enabled=no,
3435 ac_cv_posix_semaphores_enabled=yes)
3436 )
3437 AC_MSG_RESULT($ac_cv_posix_semaphores_enabled)
3438 if test $ac_cv_posix_semaphores_enabled = no
3439 then
3440 AC_DEFINE(POSIX_SEMAPHORES_NOT_ENABLED, 1,
3441 [Define if POSIX semaphores aren't enabled on your system])
3442 fi
3444 # Multiprocessing check for broken sem_getvalue
3445 AC_MSG_CHECKING(for broken sem_getvalue)
3446 AC_TRY_RUN([
3447 #include <unistd.h>
3448 #include <fcntl.h>
3449 #include <stdio.h>
3450 #include <semaphore.h>
3451 #include <sys/stat.h>
3453 int main(void){
3454 sem_t *a = sem_open("/autocftw", O_CREAT, S_IRUSR|S_IWUSR, 0);
3455 int count;
3456 int res;
3457 if(a==SEM_FAILED){
3458 perror("sem_open");
3459 return 1;
3461 }
3462 res = sem_getvalue(a, &count);
3463 sem_close(a);
3464 sem_unlink("/autocftw");
3465 return res==-1 ? 1 : 0;
3466 }
3467 ]
3468 ,AC_MSG_RESULT(no),
3469 AC_MSG_RESULT(yes)
3470 AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1, define to 1 if your sem_getvalue is broken.)
3471 )
3473 # determine what size digit to use for Python's longs
3474 AC_MSG_CHECKING([digit size for Python's longs])
3475 AC_ARG_ENABLE(big-digits,
3476 AC_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
3477 [case $enable_big_digits in
3478 yes)
3479 enable_big_digits=30 ;;
3480 no)
3481 enable_big_digits=15 ;;
3482 [15|30])
3483 ;;
3484 *)
3485 AC_MSG_ERROR([bad value $enable_big_digits for --enable-big-digits; value should be 15 or 30]) ;;
3486 esac
3487 AC_MSG_RESULT($enable_big_digits)
3488 AC_DEFINE_UNQUOTED(PYLONG_BITS_IN_DIGIT, $enable_big_digits, [Define as the preferred size in bits of long digits])
3489 ],
3490 [AC_MSG_RESULT(no value specified)])
3492 # check for wchar.h
3493 AC_CHECK_HEADER(wchar.h, [
3494 AC_DEFINE(HAVE_WCHAR_H, 1,
3495 [Define if the compiler provides a wchar.h header file.])
3496 wchar_h="yes"
3497 ],
3498 wchar_h="no"
3499 )
3501 # determine wchar_t size
3502 if test "$wchar_h" = yes
3503 then
3504 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
3505 fi
3507 AC_MSG_CHECKING(for UCS-4 tcl)
3508 have_ucs4_tcl=no
3509 AC_TRY_COMPILE([
3510 #include <tcl.h>
3511 #if TCL_UTF_MAX != 6
3512 # error "NOT UCS4_TCL"
3513 #endif], [], [
3514 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
3515 have_ucs4_tcl=yes
3516 ])
3517 AC_MSG_RESULT($have_ucs4_tcl)
3519 # check whether wchar_t is signed or not
3520 if test "$wchar_h" = yes
3521 then
3522 # check whether wchar_t is signed or not
3523 AC_MSG_CHECKING(whether wchar_t is signed)
3524 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
3525 AC_TRY_RUN([
3526 #include <wchar.h>
3527 int main()
3528 {
3529 /* Success: exit code 0 */
3530 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
3531 }
3532 ],
3533 ac_cv_wchar_t_signed=yes,
3534 ac_cv_wchar_t_signed=no,
3535 ac_cv_wchar_t_signed=yes)])
3536 AC_MSG_RESULT($ac_cv_wchar_t_signed)
3537 fi
3539 AC_MSG_CHECKING(what type to use for str)
3540 AC_ARG_WITH(wide-unicode,
3541 AC_HELP_STRING(--with-wide-unicode, Use 4-byte Unicode characters (default is 2 bytes)),
3542 [
3543 if test "$withval" != no
3544 then unicode_size="4"
3545 else unicode_size="2"
3546 fi
3547 ],
3548 [
3549 case "$have_ucs4_tcl" in
3550 yes) unicode_size="4" ;;
3551 *) unicode_size="2" ;;
3552 esac
3553 ])
3555 AH_TEMPLATE(Py_UNICODE_SIZE,
3556 [Define as the size of the unicode type.])
3557 case "$unicode_size" in
3558 4) AC_DEFINE(Py_UNICODE_SIZE, 4) ;;
3559 *) AC_DEFINE(Py_UNICODE_SIZE, 2) ;;
3560 esac
3562 AH_TEMPLATE(PY_UNICODE_TYPE,
3563 [Define as the integral type used for Unicode representation.])
3565 # wchar_t is only usable if it maps to an unsigned type
3566 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3567 -a "$ac_cv_wchar_t_signed" = "no"
3568 then
3569 PY_UNICODE_TYPE="wchar_t"
3570 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3571 [Define if you have a useable wchar_t type defined in wchar.h; useable
3572 means wchar_t must be an unsigned type with at least 16 bits. (see
3573 Include/unicodeobject.h).])
3574 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3575 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3576 then
3577 PY_UNICODE_TYPE="unsigned short"
3578 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3579 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3580 then
3581 PY_UNICODE_TYPE="unsigned long"
3582 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3583 else
3584 PY_UNICODE_TYPE="no type found"
3585 fi
3586 AC_MSG_RESULT($PY_UNICODE_TYPE)
3588 # check for endianness
3589 AC_C_BIGENDIAN
3591 # Check whether right shifting a negative integer extends the sign bit
3592 # or fills with zeros (like the Cray J90, according to Tim Peters).
3593 AC_MSG_CHECKING(whether right shift extends the sign bit)
3594 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3595 AC_TRY_RUN([
3596 int main()
3597 {
3598 exit(((-1)>>3 == -1) ? 0 : 1);
3599 }
3600 ],
3601 ac_cv_rshift_extends_sign=yes,
3602 ac_cv_rshift_extends_sign=no,
3603 ac_cv_rshift_extends_sign=yes)])
3604 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3605 if test "$ac_cv_rshift_extends_sign" = no
3606 then
3607 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3608 [Define if i>>j for signed int i does not extend the sign bit
3609 when i < 0])
3610 fi
3612 # check for getc_unlocked and related locking functions
3613 AC_MSG_CHECKING(for getc_unlocked() and friends)
3614 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3615 AC_TRY_LINK([#include <stdio.h>],[
3616 FILE *f = fopen("/dev/null", "r");
3617 flockfile(f);
3618 getc_unlocked(f);
3619 funlockfile(f);
3620 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3621 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3622 if test "$ac_cv_have_getc_unlocked" = yes
3623 then
3624 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3625 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3626 fi
3628 # check where readline lives
3629 # save the value of LIBS so we don't actually link Python with readline
3630 LIBS_no_readline=$LIBS
3632 # On some systems we need to link readline to a termcap compatible
3633 # library. NOTE: Keep the precedence of listed libraries synchronised
3634 # with setup.py.
3635 py_cv_lib_readline=no
3636 AC_MSG_CHECKING([how to link readline libs])
3637 for py_libtermcap in "" ncursesw ncurses curses termcap; do
3638 if test -z "$py_libtermcap"; then
3639 READLINE_LIBS="-lreadline"
3640 else
3641 READLINE_LIBS="-lreadline -l$py_libtermcap"
3642 fi
3643 LIBS="$READLINE_LIBS $LIBS_no_readline"
3644 AC_LINK_IFELSE(
3645 [AC_LANG_CALL([],[readline])],
3646 [py_cv_lib_readline=yes])
3647 if test $py_cv_lib_readline = yes; then
3648 break
3649 fi
3650 done
3651 # Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
3652 #AC_SUBST([READLINE_LIBS])
3653 if test $py_cv_lib_readline = no; then
3654 AC_MSG_RESULT([none])
3655 else
3656 AC_MSG_RESULT([$READLINE_LIBS])
3657 AC_DEFINE(HAVE_LIBREADLINE, 1,
3658 [Define if you have the readline library (-lreadline).])
3659 fi
3661 # check for readline 2.1
3662 AC_CHECK_LIB(readline, rl_callback_handler_install,
3663 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3664 [Define if you have readline 2.1]), ,$READLINE_LIBS)
3666 # check for readline 2.2
3667 AC_TRY_CPP([#include <readline/readline.h>],
3668 have_readline=yes, have_readline=no)
3669 if test $have_readline = yes
3670 then
3671 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3672 [readline/readline.h],
3673 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3674 [Define if you have readline 2.2]), )
3675 AC_EGREP_HEADER([extern int rl_completion_suppress_append;],
3676 [readline/readline.h],
3677 AC_DEFINE(HAVE_RL_COMPLETION_SUPPRESS_APPEND, 1,
3678 [Define if you have rl_completion_suppress_append]), )
3679 fi
3681 # check for readline 4.0
3682 AC_CHECK_LIB(readline, rl_pre_input_hook,
3683 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3684 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3686 # also in 4.0
3687 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
3688 AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
3689 [Define if you have readline 4.0]), ,$READLINE_LIBS)
3691 # check for readline 4.2
3692 AC_CHECK_LIB(readline, rl_completion_matches,
3693 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3694 [Define if you have readline 4.2]), ,$READLINE_LIBS)
3696 # also in readline 4.2
3697 AC_TRY_CPP([#include <readline/readline.h>],
3698 have_readline=yes, have_readline=no)
3699 if test $have_readline = yes
3700 then
3701 AC_EGREP_HEADER([extern int rl_catch_signals;],
3702 [readline/readline.h],
3703 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3704 [Define if you can turn off readline's signal handling.]), )
3705 fi
3707 # End of readline checks: restore LIBS
3708 LIBS=$LIBS_no_readline
3710 AC_MSG_CHECKING(for broken nice())
3711 AC_CACHE_VAL(ac_cv_broken_nice, [
3712 AC_TRY_RUN([
3713 int main()
3714 {
3715 int val1 = nice(1);
3716 if (val1 != -1 && val1 == nice(2))
3717 exit(0);
3718 exit(1);
3719 }
3720 ],
3721 ac_cv_broken_nice=yes,
3722 ac_cv_broken_nice=no,
3723 ac_cv_broken_nice=no)])
3724 AC_MSG_RESULT($ac_cv_broken_nice)
3725 if test "$ac_cv_broken_nice" = yes
3726 then
3727 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3728 [Define if nice() returns success/failure instead of the new priority.])
3729 fi
3731 AC_MSG_CHECKING(for broken poll())
3732 AC_TRY_RUN([
3733 #include <poll.h>
3735 int main (void)
3736 {
3737 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3739 close (42);
3741 int poll_test = poll (&poll_struct, 1, 0);
3743 if (poll_test < 0)
3744 {
3745 exit(0);
3746 }
3747 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3748 {
3749 exit(0);
3750 }
3751 else
3752 {
3753 exit(1);
3754 }
3755 }
3756 ],
3757 ac_cv_broken_poll=yes,
3758 ac_cv_broken_poll=no,
3759 ac_cv_broken_poll=no)
3760 AC_MSG_RESULT($ac_cv_broken_poll)
3761 if test "$ac_cv_broken_poll" = yes
3762 then
3763 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3764 [Define if poll() sets errno on invalid file descriptors.])
3765 fi
3767 # Before we can test tzset, we need to check if struct tm has a tm_zone
3768 # (which is not required by ISO C or UNIX spec) and/or if we support
3769 # tzname[]
3770 AC_STRUCT_TIMEZONE
3772 # check tzset(3) exists and works like we expect it to
3773 AC_MSG_CHECKING(for working tzset())
3774 AC_CACHE_VAL(ac_cv_working_tzset, [
3775 AC_TRY_RUN([
3776 #include <stdlib.h>
3777 #include <time.h>
3778 #include <string.h>
3780 #if HAVE_TZNAME
3781 extern char *tzname[];
3782 #endif
3784 int main()
3785 {
3786 /* Note that we need to ensure that not only does tzset(3)
3787 do 'something' with localtime, but it works as documented
3788 in the library reference and as expected by the test suite.
3789 This includes making sure that tzname is set properly if
3790 tm->tm_zone does not exist since it is the alternative way
3791 of getting timezone info.
3793 Red Hat 6.2 doesn't understand the southern hemisphere
3794 after New Year's Day.
3795 */
3797 time_t groundhogday = 1044144000; /* GMT-based */
3798 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3800 putenv("TZ=UTC+0");
3801 tzset();
3802 if (localtime(&groundhogday)->tm_hour != 0)
3803 exit(1);
3804 #if HAVE_TZNAME
3805 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3806 if (strcmp(tzname[0], "UTC") ||
3807 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3808 exit(1);
3809 #endif
3811 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3812 tzset();
3813 if (localtime(&groundhogday)->tm_hour != 19)
3814 exit(1);
3815 #if HAVE_TZNAME
3816 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3817 exit(1);
3818 #endif
3820 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3821 tzset();
3822 if (localtime(&groundhogday)->tm_hour != 11)
3823 exit(1);
3824 #if HAVE_TZNAME
3825 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3826 exit(1);
3827 #endif
3829 #if HAVE_STRUCT_TM_TM_ZONE
3830 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3831 exit(1);
3832 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3833 exit(1);
3834 #endif
3836 exit(0);
3837 }
3838 ],
3839 ac_cv_working_tzset=yes,
3840 ac_cv_working_tzset=no,
3841 ac_cv_working_tzset=no)])
3842 AC_MSG_RESULT($ac_cv_working_tzset)
3843 if test "$ac_cv_working_tzset" = yes
3844 then
3845 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3846 [Define if tzset() actually switches the local timezone in a meaningful way.])
3847 fi
3849 # Look for subsecond timestamps in struct stat
3850 AC_MSG_CHECKING(for tv_nsec in struct stat)
3851 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3852 AC_TRY_COMPILE([#include <sys/stat.h>], [
3853 struct stat st;
3854 st.st_mtim.tv_nsec = 1;
3855 ],
3856 ac_cv_stat_tv_nsec=yes,
3857 ac_cv_stat_tv_nsec=no,
3858 ac_cv_stat_tv_nsec=no))
3859 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3860 if test "$ac_cv_stat_tv_nsec" = yes
3861 then
3862 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3863 [Define if you have struct stat.st_mtim.tv_nsec])
3864 fi
3866 # Look for BSD style subsecond timestamps in struct stat
3867 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3868 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3869 AC_TRY_COMPILE([#include <sys/stat.h>], [
3870 struct stat st;
3871 st.st_mtimespec.tv_nsec = 1;
3872 ],
3873 ac_cv_stat_tv_nsec2=yes,
3874 ac_cv_stat_tv_nsec2=no,
3875 ac_cv_stat_tv_nsec2=no))
3876 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3877 if test "$ac_cv_stat_tv_nsec2" = yes
3878 then
3879 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3880 [Define if you have struct stat.st_mtimensec])
3881 fi
3883 # On HP/UX 11.0, mvwdelch is a block with a return statement
3884 AC_MSG_CHECKING(whether mvwdelch is an expression)
3885 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3886 AC_TRY_COMPILE([#include <curses.h>], [
3887 int rtn;
3888 rtn = mvwdelch(0,0,0);
3889 ], ac_cv_mvwdelch_is_expression=yes,
3890 ac_cv_mvwdelch_is_expression=no,
3891 ac_cv_mvwdelch_is_expression=yes))
3892 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3894 if test "$ac_cv_mvwdelch_is_expression" = yes
3895 then
3896 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3897 [Define if mvwdelch in curses.h is an expression.])
3898 fi
3900 AC_MSG_CHECKING(whether WINDOW has _flags)
3901 AC_CACHE_VAL(ac_cv_window_has_flags,
3902 AC_TRY_COMPILE([#include <curses.h>], [
3903 WINDOW *w;
3904 w->_flags = 0;
3905 ], ac_cv_window_has_flags=yes,
3906 ac_cv_window_has_flags=no,
3907 ac_cv_window_has_flags=no))
3908 AC_MSG_RESULT($ac_cv_window_has_flags)
3911 if test "$ac_cv_window_has_flags" = yes
3912 then
3913 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3914 [Define if WINDOW in curses.h offers a field _flags.])
3915 fi
3917 AC_MSG_CHECKING(for is_term_resized)
3918 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3919 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3920 AC_MSG_RESULT(yes),
3921 AC_MSG_RESULT(no)
3922 )
3924 AC_MSG_CHECKING(for resize_term)
3925 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3926 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3927 AC_MSG_RESULT(yes),
3928 AC_MSG_RESULT(no)
3929 )
3931 AC_MSG_CHECKING(for resizeterm)
3932 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3933 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3934 AC_MSG_RESULT(yes),
3935 AC_MSG_RESULT(no)
3936 )
3938 AC_MSG_CHECKING(for /dev/ptmx)
3940 if test -r /dev/ptmx
3941 then
3942 AC_MSG_RESULT(yes)
3943 AC_DEFINE(HAVE_DEV_PTMX, 1,
3944 [Define if we have /dev/ptmx.])
3945 else
3946 AC_MSG_RESULT(no)
3947 fi
3949 AC_MSG_CHECKING(for /dev/ptc)
3951 if test -r /dev/ptc
3952 then
3953 AC_MSG_RESULT(yes)
3954 AC_DEFINE(HAVE_DEV_PTC, 1,
3955 [Define if we have /dev/ptc.])
3956 else
3957 AC_MSG_RESULT(no)
3958 fi
3960 AC_MSG_CHECKING(for %zd printf() format support)
3961 AC_TRY_RUN([#include <stdio.h>
3962 #include <stddef.h>
3963 #include <string.h>
3965 #ifdef HAVE_SYS_TYPES_H
3966 #include <sys/types.h>
3967 #endif
3969 #ifdef HAVE_SSIZE_T
3970 typedef ssize_t Py_ssize_t;
3971 #elif SIZEOF_VOID_P == SIZEOF_LONG
3972 typedef long Py_ssize_t;
3973 #else
3974 typedef int Py_ssize_t;
3975 #endif
3977 int main()
3978 {
3979 char buffer[256];
3981 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3982 return 1;
3984 if (strcmp(buffer, "123"))
3985 return 1;
3987 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3988 return 1;
3990 if (strcmp(buffer, "-123"))
3991 return 1;
3993 return 0;
3994 }],
3995 [AC_MSG_RESULT(yes)
3996 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3997 AC_MSG_RESULT(no))
3999 AC_CHECK_TYPE(socklen_t,,
4000 AC_DEFINE(socklen_t,int,
4001 Define to `int' if <sys/socket.h> does not define.),[
4002 #ifdef HAVE_SYS_TYPES_H
4003 #include <sys/types.h>
4004 #endif
4005 #ifdef HAVE_SYS_SOCKET_H
4006 #include <sys/socket.h>
4007 #endif
4008 ])
4010 AC_MSG_CHECKING(for broken mbstowcs)
4011 AC_TRY_RUN([
4012 #include<stdlib.h>
4013 int main() {
4014 size_t len = -1;
4015 const char *str = "text";
4016 len = mbstowcs(NULL, str, 0);
4017 return (len != 4);
4018 }
4019 ],
4020 ac_cv_broken_mbstowcs=no,
4021 ac_cv_broken_mbstowcs=yes,
4022 ac_cv_broken_mbstowcs=no)
4023 AC_MSG_RESULT($ac_cv_broken_mbstowcs)
4024 if test "$ac_cv_broken_mbstowcs" = yes
4025 then
4026 AC_DEFINE(HAVE_BROKEN_MBSTOWCS, 1,
4027 [Define if mbstowcs(NULL, "text", 0) does not return the number of
4028 wide chars that would be converted.])
4029 fi
4031 # Check for --with-computed-gotos
4032 AC_MSG_CHECKING(for --with-computed-gotos)
4033 AC_ARG_WITH(computed-gotos,
4034 AC_HELP_STRING(--with-computed-gotos,
4035 Use computed gotos / threaded dispatch in evaluation loop (not available on all compilers)),
4036 [
4037 if test "$withval" != no
4038 then
4039 AC_DEFINE(USE_COMPUTED_GOTOS, 1,
4040 [Define if you want to use computed gotos in ceval.c.])
4041 AC_MSG_RESULT(yes)
4042 else AC_MSG_RESULT(no)
4043 fi],
4044 [AC_MSG_RESULT(no)])
4046 if test $ac_sys_system = Darwin
4047 then
4048 LIBS="$LIBS -framework CoreFoundation"
4049 fi
4053 AC_SUBST(THREADHEADERS)
4055 for h in `(cd $srcdir;echo Python/thread_*.h)`
4056 do
4057 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
4058 done
4060 AC_SUBST(SRCDIRS)
4061 SRCDIRS="Parser Grammar Objects Python Modules Mac"
4062 AC_MSG_CHECKING(for build directories)
4063 for dir in $SRCDIRS; do
4064 if test ! -d $dir; then
4065 mkdir $dir
4066 fi
4067 done
4068 AC_MSG_RESULT(done)
4070 # generate output files
4071 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config Misc/python.pc)
4072 AC_OUTPUT
4074 echo "creating Modules/Setup"
4075 if test ! -f Modules/Setup
4076 then
4077 cp $srcdir/Modules/Setup.dist Modules/Setup
4078 fi
4080 echo "creating Modules/Setup.local"
4081 if test ! -f Modules/Setup.local
4082 then
4083 echo "# Edit this file for local setup changes" >Modules/Setup.local
4084 fi
4086 echo "creating Makefile"
4087 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
4088 -s Modules Modules/Setup.config \
4089 Modules/Setup.local Modules/Setup
4090 mv config.c Modules