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