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