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