| blob | 7480ee64a141f2656c077d18b64f419ef4c041e1 |
1 dnl Process this file with autoconf 2.0 or later to make a configure script.
3 # Set VERSION so we only need to edit in one place (i.e., here)
4 m4_define(PYTHON_VERSION, 2.6)
6 AC_REVISION($Revision$)
7 AC_PREREQ(2.61)
8 AC_INIT(python, PYTHON_VERSION, http://www.python.org/python-bugs)
9 AC_CONFIG_SRCDIR([Include/object.h])
10 AC_CONFIG_HEADER(pyconfig.h)
12 dnl This is for stuff that absolutely must end up in pyconfig.h.
13 dnl Please use pyport.h instead, if possible.
14 AH_TOP([
15 #ifndef Py_PYCONFIG_H
16 #define Py_PYCONFIG_H
17 ])
18 AH_BOTTOM([
19 /* Define the macros needed if on a UnixWare 7.x system. */
20 #if defined(__USLC__) && defined(__SCO_VERSION__)
21 #define STRICT_SYSV_CURSES /* Don't use ncurses extensions */
22 #endif
24 #endif /*Py_PYCONFIG_H*/
25 ])
27 # We don't use PACKAGE_ variables, and they cause conflicts
28 # with other autoconf-based packages that include Python.h
29 grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
30 rm confdefs.h
31 mv confdefs.h.new confdefs.h
33 AC_SUBST(VERSION)
34 VERSION=PYTHON_VERSION
36 AC_SUBST(SOVERSION)
37 SOVERSION=1.0
39 # The later defininition of _XOPEN_SOURCE disables certain features
40 # on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
41 AC_DEFINE(_GNU_SOURCE, 1, [Define on Linux to activate all library features])
43 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
44 # certain features on NetBSD, so we need _NETBSD_SOURCE to re-enable
45 # them.
46 AC_DEFINE(_NETBSD_SOURCE, 1, [Define on NetBSD to activate all library features])
48 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
49 # certain features on FreeBSD, so we need __BSD_VISIBLE to re-enable
50 # them.
51 AC_DEFINE(__BSD_VISIBLE, 1, [Define on FreeBSD to activate all library features])
53 # OpenBSD undoes our definition of __BSD_VISIBLE if _XOPEN_SOURCE is
54 # also defined. This can be overridden by defining _BSD_SOURCE
55 AC_DEFINE(_BSD_SOURCE, 1, [Define on OpenBSD to activate all library features])
57 # The later defininition of _XOPEN_SOURCE and _POSIX_C_SOURCE disables
58 # u_int on Irix 5.3. Defining _BSD_TYPES brings it back.
59 AC_DEFINE(_BSD_TYPES, 1, [Define on Irix to enable u_int])
61 define_xopen_source=yes
63 # Arguments passed to configure.
64 AC_SUBST(CONFIG_ARGS)
65 CONFIG_ARGS="$ac_configure_args"
67 AC_ARG_ENABLE(universalsdk,
68 AC_HELP_STRING(--enable-universalsdk@<:@SDKDIR@:>@, Build agains Mac OS X 10.4u SDK (ppc/i386)),
69 [
70 case $enableval in
71 yes)
72 enableval=/Developer/SDKs/MacOSX10.4u.sdk
73 ;;
74 esac
75 case $enableval in
76 no)
77 UNIVERSALSDK=
78 enable_universalsdk=
79 ;;
80 *)
81 UNIVERSALSDK=$enableval
82 ;;
83 esac
84 ],[
85 UNIVERSALSDK=
86 enable_universalsdk=
87 ])
88 AC_SUBST(UNIVERSALSDK)
90 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
91 AC_ARG_ENABLE(framework,
92 AC_HELP_STRING(--enable-framework@<:@=INSTALLDIR@:>@, Build (MacOSX|Darwin) framework),
93 [
94 case $enableval in
95 yes)
96 enableval=/Library/Frameworks
97 esac
98 case $enableval in
99 no)
100 PYTHONFRAMEWORK=
101 PYTHONFRAMEWORKDIR=no-framework
102 PYTHONFRAMEWORKPREFIX=
103 PYTHONFRAMEWORKINSTALLDIR=
104 FRAMEWORKINSTALLFIRST=
105 FRAMEWORKINSTALLLAST=
106 FRAMEWORKALTINSTALLFIRST=
107 FRAMEWORKALTINSTALLLAST=
108 if test "x${prefix}" = "xNONE"; then
109 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
110 else
111 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
112 fi
113 enable_framework=
114 ;;
115 *)
116 PYTHONFRAMEWORK=Python
117 PYTHONFRAMEWORKDIR=Python.framework
118 PYTHONFRAMEWORKPREFIX=$enableval
119 PYTHONFRAMEWORKINSTALLDIR=$PYTHONFRAMEWORKPREFIX/$PYTHONFRAMEWORKDIR
120 FRAMEWORKINSTALLFIRST="frameworkinstallstructure"
121 FRAMEWORKINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools"
122 FRAMEWORKALTINSTALLFIRST="${FRAMEWORKINSTALLFIRST} bininstall maninstall"
123 FRAMEWORKALTINSTALLLAST="frameworkinstallmaclib frameworkinstallapps frameworkaltinstallunixtools"
124 if test "x${prefix}" = "xNONE" ; then
125 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
126 else
127 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
128 fi
129 prefix=$PYTHONFRAMEWORKINSTALLDIR/Versions/$VERSION
131 # Add makefiles for Mac specific code to the list of output
132 # files:
133 AC_CONFIG_FILES(Mac/Makefile)
134 AC_CONFIG_FILES(Mac/PythonLauncher/Makefile)
135 AC_CONFIG_FILES(Mac/IDLE/Makefile)
136 esac
137 ],[
138 PYTHONFRAMEWORK=
139 PYTHONFRAMEWORKDIR=no-framework
140 PYTHONFRAMEWORKPREFIX=
141 PYTHONFRAMEWORKINSTALLDIR=
142 FRAMEWORKINSTALLFIRST=
143 FRAMEWORKINSTALLLAST=
144 FRAMEWORKALTINSTALLFIRST=
145 FRAMEWORKALTINSTALLLAST=
146 if test "x${prefix}" = "xNONE" ; then
147 FRAMEWORKUNIXTOOLSPREFIX="${ac_default_prefix}"
148 else
149 FRAMEWORKUNIXTOOLSPREFIX="${prefix}"
150 fi
151 enable_framework=
152 ])
153 AC_SUBST(PYTHONFRAMEWORK)
154 AC_SUBST(PYTHONFRAMEWORKDIR)
155 AC_SUBST(PYTHONFRAMEWORKPREFIX)
156 AC_SUBST(PYTHONFRAMEWORKINSTALLDIR)
157 AC_SUBST(FRAMEWORKINSTALLFIRST)
158 AC_SUBST(FRAMEWORKINSTALLLAST)
159 AC_SUBST(FRAMEWORKALTINSTALLFIRST)
160 AC_SUBST(FRAMEWORKALTINSTALLLAST)
161 AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX)
163 ##AC_ARG_WITH(dyld,
164 ## AC_HELP_STRING(--with-dyld,
165 ## Use (OpenStep|Rhapsody) dynamic linker))
166 ##
167 # Set name for machine-dependent library files
168 AC_SUBST(MACHDEP)
169 AC_MSG_CHECKING(MACHDEP)
170 if test -z "$MACHDEP"
171 then
172 ac_sys_system=`uname -s`
173 if test "$ac_sys_system" = "AIX" -o "$ac_sys_system" = "Monterey64" \
174 -o "$ac_sys_system" = "UnixWare" -o "$ac_sys_system" = "OpenUNIX"; then
175 ac_sys_release=`uname -v`
176 else
177 ac_sys_release=`uname -r`
178 fi
179 ac_md_system=`echo $ac_sys_system |
180 tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
181 ac_md_release=`echo $ac_sys_release |
182 tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
183 MACHDEP="$ac_md_system$ac_md_release"
185 case $MACHDEP in
186 cygwin*) MACHDEP="cygwin";;
187 darwin*) MACHDEP="darwin";;
188 atheos*) MACHDEP="atheos";;
189 irix646) MACHDEP="irix6";;
190 '') MACHDEP="unknown";;
191 esac
192 fi
194 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
195 # disable features if it is defined, without any means to access these
196 # features as extensions. For these systems, we skip the definition of
197 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
198 # some feature, make sure there is no alternative way to access this
199 # feature. Also, when using wildcards, make sure you have verified the
200 # need for not defining _XOPEN_SOURCE on all systems matching the
201 # wildcard, and that the wildcard does not include future systems
202 # (which may remove their limitations).
203 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
204 case $ac_sys_system/$ac_sys_release in
205 # On OpenBSD, select(2) is not available if _XOPEN_SOURCE is defined,
206 # even though select is a POSIX function. Reported by J. Ribbens.
207 # Reconfirmed for OpenBSD 3.3 by Zachary Hamm, for 3.4 by Jason Ish.
208 OpenBSD/2.* | OpenBSD/3.@<:@0123456789@:>@ | OpenBSD/4.@<:@0@:>@)
209 define_xopen_source=no;;
210 # Defining _XOPEN_SOURCE on NetBSD version prior to the introduction of
211 # _NETBSD_SOURCE disables certain features (eg. setgroups). Reported by
212 # Marc Recht
213 NetBSD/1.5 | NetBSD/1.5.* | NetBSD/1.6 | NetBSD/1.6.* | NetBSD/1.6[A-S])
214 define_xopen_source=no;;
215 # On Solaris 2.6, sys/wait.h is inconsistent in the usage
216 # of union __?sigval. Reported by Stuart Bishop.
217 SunOS/5.6)
218 define_xopen_source=no;;
219 # On UnixWare 7, u_long is never defined with _XOPEN_SOURCE,
220 # but used in /usr/include/netinet/tcp.h. Reported by Tim Rice.
221 # Reconfirmed for 7.1.4 by Martin v. Loewis.
222 OpenUNIX/8.0.0| UnixWare/7.1.@<:@0-4@:>@)
223 define_xopen_source=no;;
224 # On OpenServer 5, u_short is never defined with _XOPEN_SOURCE,
225 # but used in struct sockaddr.sa_family. Reported by Tim Rice.
226 SCO_SV/3.2)
227 define_xopen_source=no;;
228 # On FreeBSD 4.8 and MacOS X 10.2, a bug in ncurses.h means that
229 # it craps out if _XOPEN_EXTENDED_SOURCE is defined. Apparently,
230 # this is fixed in 10.3, which identifies itself as Darwin/7.*
231 # This should hopefully be fixed in FreeBSD 4.9
232 FreeBSD/4.8* | Darwin/6* )
233 define_xopen_source=no;;
234 # On AIX 4 and 5.1, mbstate_t is defined only when _XOPEN_SOURCE == 500 but
235 # used in wcsnrtombs() and mbsnrtowcs() even if _XOPEN_SOURCE is not defined
236 # or has another value. By not (re)defining it, the defaults come in place.
237 AIX/4)
238 define_xopen_source=no;;
239 AIX/5)
240 if test `uname -r` -eq 1; then
241 define_xopen_source=no
242 fi
243 ;;
244 # On Mac OS X 10.4, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
245 # disables platform specific features beyond repair.
246 # On Mac OS X 10.3, defining _POSIX_C_SOURCE or _XOPEN_SOURCE
247 # has no effect, don't bother defining them
248 Darwin/@<:@789@:>@.*)
249 define_xopen_source=no
250 ;;
252 esac
254 if test $define_xopen_source = yes
255 then
256 # On Solaris w/ g++ it appears that _XOPEN_SOURCE has to be
257 # defined precisely as g++ defines it
258 # Furthermore, on Solaris 10, XPG6 requires the use of a C99
259 # compiler
260 case $ac_sys_system/$ac_sys_release in
261 SunOS/5.8|SunOS/5.9|SunOS/5.10)
262 AC_DEFINE(_XOPEN_SOURCE, 500,
263 Define to the level of X/Open that your system supports)
264 ;;
265 *)
266 AC_DEFINE(_XOPEN_SOURCE, 600,
267 Define to the level of X/Open that your system supports)
268 ;;
269 esac
271 # On Tru64 Unix 4.0F, defining _XOPEN_SOURCE also requires
272 # definition of _XOPEN_SOURCE_EXTENDED and _POSIX_C_SOURCE, or else
273 # several APIs are not declared. Since this is also needed in some
274 # cases for HP-UX, we define it globally.
275 # except for Solaris 10, where it must not be defined,
276 # as it implies XPG4.2
277 case $ac_sys_system/$ac_sys_release in
278 SunOS/5.10)
279 ;;
280 *)
281 AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1,
282 Define to activate Unix95-and-earlier features)
283 ;;
284 esac
286 AC_DEFINE(_POSIX_C_SOURCE, 200112L, Define to activate features from IEEE Stds 1003.1-2001)
288 fi
290 #
291 # SGI compilers allow the specification of the both the ABI and the
292 # ISA on the command line. Depending on the values of these switches,
293 # different and often incompatable code will be generated.
294 #
295 # The SGI_ABI variable can be used to modify the CC and LDFLAGS and
296 # thus supply support for various ABI/ISA combinations. The MACHDEP
297 # variable is also adjusted.
298 #
299 AC_SUBST(SGI_ABI)
300 if test ! -z "$SGI_ABI"
301 then
302 CC="cc $SGI_ABI"
303 LDFLAGS="$SGI_ABI $LDFLAGS"
304 MACHDEP=`echo "${MACHDEP}${SGI_ABI}" | sed 's/ *//g'`
305 fi
306 AC_MSG_RESULT($MACHDEP)
308 # And add extra plat-mac for darwin
309 AC_SUBST(EXTRAPLATDIR)
310 AC_SUBST(EXTRAMACHDEPPATH)
311 AC_MSG_CHECKING(EXTRAPLATDIR)
312 if test -z "$EXTRAPLATDIR"
313 then
314 case $MACHDEP in
315 darwin)
316 EXTRAPLATDIR="\$(PLATMACDIRS)"
317 EXTRAMACHDEPPATH="\$(PLATMACPATH)"
318 ;;
319 *)
320 EXTRAPLATDIR=""
321 EXTRAMACHDEPPATH=""
322 ;;
323 esac
324 fi
325 AC_MSG_RESULT($EXTRAPLATDIR)
327 # Record the configure-time value of MACOSX_DEPLOYMENT_TARGET,
328 # it may influence the way we can build extensions, so distutils
329 # needs to check it
330 AC_SUBST(CONFIGURE_MACOSX_DEPLOYMENT_TARGET)
331 AC_SUBST(EXPORT_MACOSX_DEPLOYMENT_TARGET)
332 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=
333 EXPORT_MACOSX_DEPLOYMENT_TARGET='#'
335 # checks for alternative programs
337 # compiler flags are generated in two sets, BASECFLAGS and OPT. OPT is just
338 # for debug/optimization stuff. BASECFLAGS is for flags that are required
339 # just to get things to compile and link. Users are free to override OPT
340 # when running configure or make. The build should not break if they do.
341 # BASECFLAGS should generally not be messed with, however.
343 # XXX shouldn't some/most/all of this code be merged with the stuff later
344 # on that fiddles with OPT and BASECFLAGS?
345 AC_MSG_CHECKING(for --without-gcc)
346 AC_ARG_WITH(gcc,
347 AC_HELP_STRING(--without-gcc,never use gcc),
348 [
349 case $withval in
350 no) CC=cc
351 without_gcc=yes;;
352 yes) CC=gcc
353 without_gcc=no;;
354 *) CC=$withval
355 without_gcc=$withval;;
356 esac], [
357 case $ac_sys_system in
358 AIX*) CC=cc_r
359 without_gcc=;;
360 BeOS*)
361 case $BE_HOST_CPU in
362 ppc)
363 CC=mwcc
364 without_gcc=yes
365 BASECFLAGS="$BASECFLAGS -export pragma"
366 OPT="$OPT -O"
367 LDFLAGS="$LDFLAGS -nodup"
368 ;;
369 x86)
370 CC=gcc
371 without_gcc=no
372 OPT="$OPT -O"
373 ;;
374 *)
375 AC_MSG_ERROR([Unknown BeOS platform "$BE_HOST_CPU"])
376 ;;
377 esac
378 AR="\$(srcdir)/Modules/ar_beos"
379 RANLIB=:
380 ;;
381 Monterey*)
382 RANLIB=:
383 without_gcc=;;
384 *) without_gcc=no;;
385 esac])
386 AC_MSG_RESULT($without_gcc)
388 # If the user switches compilers, we can't believe the cache
389 if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
390 then
391 AC_MSG_ERROR([cached CC is different -- throw away $cache_file
392 (it is also a good idea to do 'make clean' before compiling)])
393 fi
395 AC_PROG_CC
397 AC_SUBST(CXX)
398 AC_SUBST(MAINCC)
399 AC_MSG_CHECKING(for --with-cxx-main=<compiler>)
400 AC_ARG_WITH(cxx_main,
401 AC_HELP_STRING([--with-cxx-main=<compiler>],
402 [compile main() and link python executable with C++ compiler]),
403 [
405 case $withval in
406 no) with_cxx_main=no
407 MAINCC='$(CC)';;
408 yes) with_cxx_main=yes
409 MAINCC='$(CXX)';;
410 *) with_cxx_main=yes
411 MAINCC=$withval
412 if test -z "$CXX"
413 then
414 CXX=$withval
415 fi;;
416 esac], [
417 with_cxx_main=no
418 MAINCC='$(CC)'
419 ])
420 AC_MSG_RESULT($with_cxx_main)
422 preset_cxx="$CXX"
423 if test -z "$CXX"
424 then
425 case "$CC" in
426 gcc) AC_PATH_PROG(CXX, [g++], [g++], [notfound]) ;;
427 cc) AC_PATH_PROG(CXX, [c++], [c++], [notfound]) ;;
428 esac
429 if test "$CXX" = "notfound"
430 then
431 CXX=""
432 fi
433 fi
434 if test -z "$CXX"
435 then
436 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, notfound)
437 if test "$CXX" = "notfound"
438 then
439 CXX=""
440 fi
441 fi
442 if test "$preset_cxx" != "$CXX"
443 then
444 AC_MSG_WARN([
446 By default, distutils will build C++ extension modules with "$CXX".
447 If this is not intended, then set CXX on the configure command line.
448 ])
449 fi
452 # checks for UNIX variants that set C preprocessor variables
453 AC_AIX
455 # Check for unsupported systems
456 case $ac_sys_system/$ac_sys_release in
457 atheos*|Linux*/1*)
458 echo This system \($ac_sys_system/$ac_sys_release\) is no longer supported.
459 echo See README for details.
460 exit 1;;
461 esac
463 AC_EXEEXT
464 AC_MSG_CHECKING(for --with-suffix)
465 AC_ARG_WITH(suffix,
466 AC_HELP_STRING(--with-suffix=.exe, set executable suffix),
467 [
468 case $withval in
469 no) EXEEXT=;;
470 yes) EXEEXT=.exe;;
471 *) EXEEXT=$withval;;
472 esac])
473 AC_MSG_RESULT($EXEEXT)
475 # Test whether we're running on a non-case-sensitive system, in which
476 # case we give a warning if no ext is given
477 AC_SUBST(BUILDEXEEXT)
478 AC_MSG_CHECKING(for case-insensitive build directory)
479 if test ! -d CaseSensitiveTestDir; then
480 mkdir CaseSensitiveTestDir
481 fi
483 if test -d casesensitivetestdir
484 then
485 AC_MSG_RESULT(yes)
486 BUILDEXEEXT=.exe
487 else
488 AC_MSG_RESULT(no)
489 BUILDEXEEXT=$EXEEXT
490 fi
491 rmdir CaseSensitiveTestDir
493 case $MACHDEP in
494 bsdos*)
495 case $CC in
496 gcc) CC="$CC -D_HAVE_BSDI";;
497 esac;;
498 esac
500 case $ac_sys_system in
501 hp*|HP*)
502 case $CC in
503 cc|*/cc) CC="$CC -Ae";;
504 esac;;
505 Monterey*)
506 case $CC in
507 cc) CC="$CC -Wl,-Bexport";;
508 esac;;
509 SunOS*)
510 # Some functions have a prototype only with that define, e.g. confstr
511 AC_DEFINE(__EXTENSIONS__, 1, [Defined on Solaris to see additional function prototypes.])
512 ;;
513 esac
516 AC_SUBST(LIBRARY)
517 AC_MSG_CHECKING(LIBRARY)
518 if test -z "$LIBRARY"
519 then
520 LIBRARY='libpython$(VERSION).a'
521 fi
522 AC_MSG_RESULT($LIBRARY)
524 # LDLIBRARY is the name of the library to link against (as opposed to the
525 # name of the library into which to insert object files). BLDLIBRARY is also
526 # the library to link against, usually. On Mac OS X frameworks, BLDLIBRARY
527 # is blank as the main program is not linked directly against LDLIBRARY.
528 # LDLIBRARYDIR is the path to LDLIBRARY, which is made in a subdirectory. On
529 # systems without shared libraries, LDLIBRARY is the same as LIBRARY
530 # (defined in the Makefiles). On Cygwin LDLIBRARY is the import library,
531 # DLLLIBRARY is the shared (i.e., DLL) library.
532 #
533 # RUNSHARED is used to run shared python without installed libraries
534 #
535 # INSTSONAME is the name of the shared library that will be use to install
536 # on the system - some systems like version suffix, others don't
537 AC_SUBST(LDLIBRARY)
538 AC_SUBST(DLLLIBRARY)
539 AC_SUBST(BLDLIBRARY)
540 AC_SUBST(LDLIBRARYDIR)
541 AC_SUBST(INSTSONAME)
542 AC_SUBST(RUNSHARED)
543 LDLIBRARY="$LIBRARY"
544 BLDLIBRARY='$(LDLIBRARY)'
545 INSTSONAME='$(LDLIBRARY)'
546 DLLLIBRARY=''
547 LDLIBRARYDIR=''
548 RUNSHARED=''
550 # LINKCC is the command that links the python executable -- default is $(CC).
551 # If CXX is set, and if it is needed to link a main function that was
552 # compiled with CXX, LINKCC is CXX instead. Always using CXX is undesirable:
553 # python might then depend on the C++ runtime
554 # This is altered for AIX in order to build the export list before
555 # linking.
556 AC_SUBST(LINKCC)
557 AC_MSG_CHECKING(LINKCC)
558 if test -z "$LINKCC"
559 then
560 LINKCC='$(PURIFY) $(MAINCC)'
561 case $ac_sys_system in
562 AIX*)
563 exp_extra="\"\""
564 if test $ac_sys_release -ge 5 -o \
565 $ac_sys_release -eq 4 -a `uname -r` -ge 2 ; then
566 exp_extra="."
567 fi
568 LINKCC="\$(srcdir)/Modules/makexp_aix Modules/python.exp $exp_extra \$(LIBRARY); $LINKCC";;
569 Monterey64*)
570 LINKCC="$LINKCC -L/usr/lib/ia64l64";;
571 esac
572 fi
573 AC_MSG_RESULT($LINKCC)
575 AC_MSG_CHECKING(for --enable-shared)
576 AC_ARG_ENABLE(shared,
577 AC_HELP_STRING(--enable-shared, disable/enable building shared python library))
579 if test -z "$enable_shared"
580 then
581 case $ac_sys_system in
582 CYGWIN* | atheos*)
583 enable_shared="yes";;
584 *)
585 enable_shared="no";;
586 esac
587 fi
588 AC_MSG_RESULT($enable_shared)
590 AC_MSG_CHECKING(for --enable-profiling)
591 AC_ARG_ENABLE(profiling,
592 AC_HELP_STRING(--enable-profiling, enable C-level code profiling),
593 [ac_save_cc="$CC"
594 CC="$CC -pg"
595 AC_TRY_RUN([int main() { return 0; }],
596 ac_enable_profiling="yes",
597 ac_enable_profiling="no",
598 ac_enable_profiling="no")
599 CC="$ac_save_cc"])
600 AC_MSG_RESULT($ac_enable_profiling)
602 case "$ac_enable_profiling" in
603 "yes")
604 BASECFLAGS="-pg $BASECFLAGS"
605 LDFLAGS="-pg $LDFLAGS"
606 ;;
607 esac
609 AC_MSG_CHECKING(LDLIBRARY)
611 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
612 # library that we build, but we do not want to link against it (we
613 # will find it with a -framework option). For this reason there is an
614 # extra variable BLDLIBRARY against which Python and the extension
615 # modules are linked, BLDLIBRARY. This is normally the same as
616 # LDLIBRARY, but empty for MacOSX framework builds.
617 if test "$enable_framework"
618 then
619 LDLIBRARY='$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
620 RUNSHARED=DYLD_FRAMEWORK_PATH="`pwd`:$DYLD_FRAMEWORK_PATH"
621 BLDLIBRARY=''
622 else
623 BLDLIBRARY='$(LDLIBRARY)'
624 fi
626 # Other platforms follow
627 if test $enable_shared = "yes"; then
628 AC_DEFINE(Py_ENABLE_SHARED, 1, [Defined if Python is built as a shared library.])
629 case $ac_sys_system in
630 BeOS*)
631 LDLIBRARY='libpython$(VERSION).so'
632 ;;
633 CYGWIN*)
634 LDLIBRARY='libpython$(VERSION).dll.a'
635 DLLLIBRARY='libpython$(VERSION).dll'
636 ;;
637 SunOS*)
638 LDLIBRARY='libpython$(VERSION).so'
639 BLDLIBRARY='-Wl,-R,$(LIBDIR) -L. -lpython$(VERSION)'
640 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
641 INSTSONAME="$LDLIBRARY".$SOVERSION
642 ;;
643 Linux*|GNU*|NetBSD*|FreeBSD*|DragonFly*)
644 LDLIBRARY='libpython$(VERSION).so'
645 BLDLIBRARY='-L. -lpython$(VERSION)'
646 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
647 case $ac_sys_system in
648 FreeBSD*)
649 SOVERSION=`echo $SOVERSION|cut -d "." -f 1`
650 ;;
651 esac
652 INSTSONAME="$LDLIBRARY".$SOVERSION
653 ;;
654 hp*|HP*)
655 case `uname -m` in
656 ia64)
657 LDLIBRARY='libpython$(VERSION).so'
658 ;;
659 *)
660 LDLIBRARY='libpython$(VERSION).sl'
661 ;;
662 esac
663 BLDLIBRARY='-Wl,+b,$(LIBDIR) -L. -lpython$(VERSION)'
664 RUNSHARED=SHLIB_PATH=`pwd`:${SHLIB_PATH}
665 ;;
666 OSF*)
667 LDLIBRARY='libpython$(VERSION).so'
668 BLDLIBRARY='-rpath $(LIBDIR) -L. -lpython$(VERSION)'
669 RUNSHARED=LD_LIBRARY_PATH=`pwd`:${LD_LIBRARY_PATH}
670 ;;
671 atheos*)
672 LDLIBRARY='libpython$(VERSION).so'
673 BLDLIBRARY='-L. -lpython$(VERSION)'
674 RUNSHARED=DLL_PATH=`pwd`:${DLL_PATH:-/atheos/sys/libs:/atheos/autolnk/lib}
675 ;;
676 esac
677 else # shared is disabled
678 case $ac_sys_system in
679 CYGWIN*)
680 BLDLIBRARY='$(LIBRARY)'
681 LDLIBRARY='libpython$(VERSION).dll.a'
682 ;;
683 esac
684 fi
686 AC_MSG_RESULT($LDLIBRARY)
688 AC_PROG_RANLIB
689 AC_SUBST(AR)
690 AC_CHECK_PROGS(AR, ar aal, ar)
692 AC_SUBST(SVNVERSION)
693 AC_CHECK_PROG(SVNVERSION, svnversion, found, not-found)
694 if test $SVNVERSION = found
695 then
696 SVNVERSION="svnversion \$(srcdir)"
697 else
698 SVNVERSION="echo exported"
699 fi
701 case $MACHDEP in
702 bsdos*|hp*|HP*)
703 # install -d does not work on BSDI or HP-UX
704 if test -z "$INSTALL"
705 then
706 INSTALL="${srcdir}/install-sh -c"
707 fi
708 esac
709 AC_PROG_INSTALL
711 # Not every filesystem supports hard links
712 AC_SUBST(LN)
713 if test -z "$LN" ; then
714 case $ac_sys_system in
715 BeOS*) LN="ln -s";;
716 CYGWIN*) LN="ln -s";;
717 atheos*) LN="ln -s";;
718 *) LN=ln;;
719 esac
720 fi
722 # Check for --with-pydebug
723 AC_MSG_CHECKING(for --with-pydebug)
724 AC_ARG_WITH(pydebug,
725 AC_HELP_STRING(--with-pydebug, build with Py_DEBUG defined),
726 [
727 if test "$withval" != no
728 then
729 AC_DEFINE(Py_DEBUG, 1,
730 [Define if you want to build an interpreter with many run-time checks.])
731 AC_MSG_RESULT(yes);
732 Py_DEBUG='true'
733 else AC_MSG_RESULT(no); Py_DEBUG='false'
734 fi],
735 [AC_MSG_RESULT(no)])
737 # XXX Shouldn't the code above that fiddles with BASECFLAGS and OPT be
738 # merged with this chunk of code?
740 # Optimizer/debugger flags
741 # ------------------------
742 # (The following bit of code is complicated enough - please keep things
743 # indented properly. Just pretend you're editing Python code. ;-)
745 # There are two parallel sets of case statements below, one that checks to
746 # see if OPT was set and one that does BASECFLAGS setting based upon
747 # compiler and platform. BASECFLAGS tweaks need to be made even if the
748 # user set OPT.
750 # tweak OPT based on compiler and platform, only if the user didn't set
751 # it on the command line
752 AC_SUBST(OPT)
753 if test -z "$OPT"
754 then
755 case $GCC in
756 yes)
757 if test "$CC" != 'g++' ; then
758 STRICT_PROTO="-Wstrict-prototypes"
759 fi
760 case $ac_cv_prog_cc_g in
761 yes)
762 if test "$Py_DEBUG" = 'true' ; then
763 # Optimization messes up debuggers, so turn it off for
764 # debug builds.
765 OPT="-g -Wall $STRICT_PROTO"
766 else
767 OPT="-g -O3 -Wall $STRICT_PROTO"
768 fi
769 ;;
770 *)
771 OPT="-O3 -Wall $STRICT_PROTO"
772 ;;
773 esac
774 case $ac_sys_system in
775 SCO_SV*) OPT="$OPT -m486 -DSCO5"
776 ;;
777 esac
778 ;;
780 *)
781 OPT="-O"
782 ;;
783 esac
785 # The current (beta) Monterey compiler dies with optimizations
786 # XXX what is Monterey? Does it still die w/ -O? Can we get rid of this?
787 case $ac_sys_system in
788 Monterey*)
789 OPT=""
790 ;;
791 esac
793 fi
795 AC_SUBST(BASECFLAGS)
796 # tweak BASECFLAGS based on compiler and platform
797 case $GCC in
798 yes)
799 # Python violates C99 rules, by casting between incompatible
800 # pointer types. GCC may generate bad code as a result of that,
801 # so use -fno-strict-aliasing if supported.
802 AC_MSG_CHECKING(whether $CC accepts -fno-strict-aliasing)
803 ac_save_cc="$CC"
804 CC="$CC -fno-strict-aliasing"
805 AC_TRY_RUN([int main() { return 0; }],
806 ac_cv_no_strict_aliasing_ok=yes,
807 ac_cv_no_strict_aliasing_ok=no,
808 ac_cv_no_strict_aliasing_ok=no)
809 CC="$ac_save_cc"
810 AC_MSG_RESULT($ac_cv_no_strict_aliasing_ok)
811 if test $ac_cv_no_strict_aliasing_ok = yes
812 then
813 BASECFLAGS="$BASECFLAGS -fno-strict-aliasing"
814 fi
815 case $ac_sys_system in
816 SCO_SV*)
817 BASECFLAGS="$BASECFLAGS -m486 -DSCO5"
818 ;;
819 # is there any other compiler on Darwin besides gcc?
820 Darwin*)
821 BASECFLAGS="$BASECFLAGS -Wno-long-double -no-cpp-precomp -mno-fused-madd"
822 if test "${enable_universalsdk}"; then
823 BASECFLAGS="-arch ppc -arch i386 -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
824 fi
826 ;;
827 OSF*)
828 BASECFLAGS="$BASECFLAGS -mieee"
829 ;;
830 esac
831 ;;
833 *)
834 case $ac_sys_system in
835 OpenUNIX*|UnixWare*)
836 BASECFLAGS="$BASECFLAGS -K pentium,host,inline,loop_unroll,alloca "
837 ;;
838 OSF*)
839 BASECFLAGS="$BASECFLAGS -ieee -std"
840 ;;
841 SCO_SV*)
842 BASECFLAGS="$BASECFLAGS -belf -Ki486 -DSCO5"
843 ;;
844 esac
845 ;;
846 esac
848 if test "$Py_DEBUG" = 'true'; then
849 :
850 else
851 OPT="-DNDEBUG $OPT"
852 fi
854 if test "$ac_arch_flags"
855 then
856 BASECFLAGS="$BASECFLAGS $ac_arch_flags"
857 fi
859 # disable check for icc since it seems to pass, but generates a warning
860 if test "$CC" = icc
861 then
862 ac_cv_opt_olimit_ok=no
863 fi
865 AC_MSG_CHECKING(whether $CC accepts -OPT:Olimit=0)
866 AC_CACHE_VAL(ac_cv_opt_olimit_ok,
867 [ac_save_cc="$CC"
868 CC="$CC -OPT:Olimit=0"
869 AC_TRY_RUN([int main() { return 0; }],
870 ac_cv_opt_olimit_ok=yes,
871 ac_cv_opt_olimit_ok=no,
872 ac_cv_opt_olimit_ok=no)
873 CC="$ac_save_cc"])
874 AC_MSG_RESULT($ac_cv_opt_olimit_ok)
875 if test $ac_cv_opt_olimit_ok = yes; then
876 case $ac_sys_system in
877 # XXX is this branch needed? On MacOSX 10.2.2 the result of the
878 # olimit_ok test is "no". Is it "yes" in some other Darwin-esque
879 # environment?
880 Darwin*)
881 ;;
882 *)
883 BASECFLAGS="$BASECFLAGS -OPT:Olimit=0"
884 ;;
885 esac
886 else
887 AC_MSG_CHECKING(whether $CC accepts -Olimit 1500)
888 AC_CACHE_VAL(ac_cv_olimit_ok,
889 [ac_save_cc="$CC"
890 CC="$CC -Olimit 1500"
891 AC_TRY_RUN([int main() { return 0; }],
892 ac_cv_olimit_ok=yes,
893 ac_cv_olimit_ok=no,
894 ac_cv_olimit_ok=no)
895 CC="$ac_save_cc"])
896 AC_MSG_RESULT($ac_cv_olimit_ok)
897 if test $ac_cv_olimit_ok = yes; then
898 BASECFLAGS="$BASECFLAGS -Olimit 1500"
899 fi
900 fi
902 # Check whether GCC supports PyArg_ParseTuple format
903 if test "$GCC" = "yes"
904 then
905 AC_MSG_CHECKING(whether gcc supports ParseTuple __format__)
906 save_CFLAGS=$CFLAGS
907 CFLAGS="$CFLAGS -Werror"
908 AC_TRY_COMPILE([
909 void f(char*,...)__attribute((format(PyArg_ParseTuple, 1, 2)));
910 ],,
911 AC_DEFINE(HAVE_ATTRIBUTE_FORMAT_PARSETUPLE, 1, [Define if GCC supports __attribute__((format(PyArg_ParseTuple, 2, 3)))])
912 AC_MSG_RESULT(yes),
913 AC_MSG_RESULT(no)
914 )
915 CFLAGS=$save_CFLAGS
916 fi
918 # On some compilers, pthreads are available without further options
919 # (e.g. MacOS X). On some of these systems, the compiler will not
920 # complain if unaccepted options are passed (e.g. gcc on Mac OS X).
921 # So we have to see first whether pthreads are available without
922 # options before we can check whether -Kpthread improves anything.
923 AC_MSG_CHECKING(whether pthreads are available without options)
924 AC_CACHE_VAL(ac_cv_pthread_is_default,
925 [AC_TRY_RUN([
926 #include <pthread.h>
928 void* routine(void* p){return NULL;}
930 int main(){
931 pthread_t p;
932 if(pthread_create(&p,NULL,routine,NULL)!=0)
933 return 1;
934 (void)pthread_detach(p);
935 return 0;
936 }
937 ],
938 [
939 ac_cv_pthread_is_default=yes
940 ac_cv_kthread=no
941 ac_cv_pthread=no
942 ],
943 ac_cv_pthread_is_default=no,
944 ac_cv_pthread_is_default=no)
945 ])
946 AC_MSG_RESULT($ac_cv_pthread_is_default)
949 if test $ac_cv_pthread_is_default = yes
950 then
951 ac_cv_kpthread=no
952 else
953 # -Kpthread, if available, provides the right #defines
954 # and linker options to make pthread_create available
955 # Some compilers won't report that they do not support -Kpthread,
956 # so we need to run a program to see whether it really made the
957 # function available.
958 AC_MSG_CHECKING(whether $CC accepts -Kpthread)
959 AC_CACHE_VAL(ac_cv_kpthread,
960 [ac_save_cc="$CC"
961 CC="$CC -Kpthread"
962 AC_TRY_RUN([
963 #include <pthread.h>
965 void* routine(void* p){return NULL;}
967 int main(){
968 pthread_t p;
969 if(pthread_create(&p,NULL,routine,NULL)!=0)
970 return 1;
971 (void)pthread_detach(p);
972 return 0;
973 }
974 ],
975 ac_cv_kpthread=yes,
976 ac_cv_kpthread=no,
977 ac_cv_kpthread=no)
978 CC="$ac_save_cc"])
979 AC_MSG_RESULT($ac_cv_kpthread)
980 fi
982 if test $ac_cv_kpthread = no -a $ac_cv_pthread_is_default = no
983 then
984 # -Kthread, if available, provides the right #defines
985 # and linker options to make pthread_create available
986 # Some compilers won't report that they do not support -Kthread,
987 # so we need to run a program to see whether it really made the
988 # function available.
989 AC_MSG_CHECKING(whether $CC accepts -Kthread)
990 AC_CACHE_VAL(ac_cv_kthread,
991 [ac_save_cc="$CC"
992 CC="$CC -Kthread"
993 AC_TRY_RUN([
994 #include <pthread.h>
996 void* routine(void* p){return NULL;}
998 int main(){
999 pthread_t p;
1000 if(pthread_create(&p,NULL,routine,NULL)!=0)
1001 return 1;
1002 (void)pthread_detach(p);
1003 return 0;
1004 }
1005 ],
1006 ac_cv_kthread=yes,
1007 ac_cv_kthread=no,
1008 ac_cv_kthread=no)
1009 CC="$ac_save_cc"])
1010 AC_MSG_RESULT($ac_cv_kthread)
1011 fi
1013 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
1014 then
1015 # -pthread, if available, provides the right #defines
1016 # and linker options to make pthread_create available
1017 # Some compilers won't report that they do not support -pthread,
1018 # so we need to run a program to see whether it really made the
1019 # function available.
1020 AC_MSG_CHECKING(whether $CC accepts -pthread)
1021 AC_CACHE_VAL(ac_cv_thread,
1022 [ac_save_cc="$CC"
1023 CC="$CC -pthread"
1024 AC_TRY_RUN([
1025 #include <pthread.h>
1027 void* routine(void* p){return NULL;}
1029 int main(){
1030 pthread_t p;
1031 if(pthread_create(&p,NULL,routine,NULL)!=0)
1032 return 1;
1033 (void)pthread_detach(p);
1034 return 0;
1035 }
1036 ],
1037 ac_cv_pthread=yes,
1038 ac_cv_pthread=no,
1039 ac_cv_pthread=no)
1040 CC="$ac_save_cc"])
1041 AC_MSG_RESULT($ac_cv_pthread)
1042 fi
1044 # If we have set a CC compiler flag for thread support then
1045 # check if it works for CXX, too.
1046 ac_cv_cxx_thread=no
1047 if test ! -z "$CXX"
1048 then
1049 AC_MSG_CHECKING(whether $CXX also accepts flags for thread support)
1050 ac_save_cxx="$CXX"
1052 if test "$ac_cv_kpthread" = "yes"
1053 then
1054 CXX="$CXX -Kpthread"
1055 ac_cv_cxx_thread=yes
1056 elif test "$ac_cv_kthread" = "yes"
1057 then
1058 CXX="$CXX -Kthread"
1059 ac_cv_cxx_thread=yes
1060 elif test "$ac_cv_pthread" = "yes"
1061 then
1062 CXX="$CXX -pthread"
1063 ac_cv_cxx_thread=yes
1064 fi
1066 if test $ac_cv_cxx_thread = yes
1067 then
1068 echo 'void foo();int main(){foo();}void foo(){}' > conftest.$ac_ext
1069 $CXX -c conftest.$ac_ext 2>&5
1070 if $CXX -o conftest$ac_exeext conftest.$ac_objext 2>&5 \
1071 && test -s conftest$ac_exeext && ./conftest$ac_exeext
1072 then
1073 ac_cv_cxx_thread=yes
1074 else
1075 ac_cv_cxx_thread=no
1076 fi
1077 rm -fr conftest*
1078 fi
1079 AC_MSG_RESULT($ac_cv_cxx_thread)
1080 fi
1081 CXX="$ac_save_cxx"
1083 dnl # check for ANSI or K&R ("traditional") preprocessor
1084 dnl AC_MSG_CHECKING(for C preprocessor type)
1085 dnl AC_TRY_COMPILE([
1086 dnl #define spam(name, doc) {#name, &name, #name "() -- " doc}
1087 dnl int foo;
1088 dnl struct {char *name; int *addr; char *doc;} desc = spam(foo, "something");
1089 dnl ], [;], cpp_type=ansi, AC_DEFINE(HAVE_OLD_CPP) cpp_type=traditional)
1090 dnl AC_MSG_RESULT($cpp_type)
1092 # checks for header files
1093 AC_HEADER_STDC
1094 AC_CHECK_HEADERS(asm/types.h conio.h curses.h direct.h dlfcn.h errno.h \
1095 fcntl.h grp.h \
1096 io.h langinfo.h libintl.h ncurses.h poll.h process.h pthread.h \
1097 shadow.h signal.h stdint.h stropts.h termios.h thread.h \
1098 unistd.h utime.h \
1099 sys/audioio.h sys/bsdtty.h sys/file.h sys/loadavg.h sys/lock.h sys/mkdev.h \
1100 sys/modem.h \
1101 sys/param.h sys/poll.h sys/select.h sys/socket.h sys/statvfs.h sys/stat.h \
1102 sys/time.h \
1103 sys/times.h sys/types.h sys/un.h sys/utsname.h sys/wait.h pty.h libutil.h \
1104 sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
1105 bluetooth/bluetooth.h)
1106 AC_HEADER_DIRENT
1107 AC_HEADER_MAJOR
1109 # On Solaris, term.h requires curses.h
1110 AC_CHECK_HEADERS(term.h,,,[
1111 #ifdef HAVE_CURSES_H
1112 #include <curses.h>
1113 #endif
1114 ])
1116 # On Linux, netlink.h requires asm/types.h
1117 AC_CHECK_HEADERS(linux/netlink.h,,,[
1118 #ifdef HAVE_ASM_TYPES_H
1119 #include <asm/types.h>
1120 #endif
1121 #ifdef HAVE_SYS_SOCKET_H
1122 #include <sys/socket.h>
1123 #endif
1124 ])
1126 # checks for typedefs
1127 was_it_defined=no
1128 AC_MSG_CHECKING(for clock_t in time.h)
1129 AC_EGREP_HEADER(clock_t, time.h, was_it_defined=yes, [
1130 AC_DEFINE(clock_t, long, [Define to 'long' if <time.h> doesn't define.])
1131 ])
1132 AC_MSG_RESULT($was_it_defined)
1134 # Check whether using makedev requires defining _OSF_SOURCE
1135 AC_MSG_CHECKING(for makedev)
1136 AC_TRY_LINK([#include <sys/types.h> ],
1137 [ makedev(0, 0) ],
1138 ac_cv_has_makedev=yes,
1139 ac_cv_has_makedev=no)
1140 if test "$ac_cv_has_makedev" = "no"; then
1141 # we didn't link, try if _OSF_SOURCE will allow us to link
1142 AC_TRY_LINK([
1143 #define _OSF_SOURCE 1
1144 #include <sys/types.h>
1145 ],
1146 [ makedev(0, 0) ],
1147 ac_cv_has_makedev=yes,
1148 ac_cv_has_makedev=no)
1149 if test "$ac_cv_has_makedev" = "yes"; then
1150 AC_DEFINE(_OSF_SOURCE, 1, [Define _OSF_SOURCE to get the makedev macro.])
1151 fi
1152 fi
1153 AC_MSG_RESULT($ac_cv_has_makedev)
1154 if test "$ac_cv_has_makedev" = "yes"; then
1155 AC_DEFINE(HAVE_MAKEDEV, 1, [Define this if you have the makedev macro.])
1156 fi
1158 # Enabling LFS on Solaris (2.6 to 9) with gcc 2.95 triggers a bug in
1159 # the system headers: If _XOPEN_SOURCE and _LARGEFILE_SOURCE are
1160 # defined, but the compiler does not support pragma redefine_extname,
1161 # and _LARGEFILE64_SOURCE is not defined, the headers refer to 64-bit
1162 # structures (such as rlimit64) without declaring them. As a
1163 # work-around, disable LFS on such configurations
1165 use_lfs=yes
1166 AC_MSG_CHECKING(Solaris LFS bug)
1167 AC_TRY_COMPILE([
1168 #define _LARGEFILE_SOURCE 1
1169 #define _FILE_OFFSET_BITS 64
1170 #include <sys/resource.h>
1171 ],struct rlimit foo;,sol_lfs_bug=no,sol_lfs_bug=yes)
1172 AC_MSG_RESULT($sol_lfs_bug)
1173 if test "$sol_lfs_bug" = "yes"; then
1174 use_lfs=no
1175 fi
1177 if test "$use_lfs" = "yes"; then
1178 # Two defines needed to enable largefile support on various platforms
1179 # These may affect some typedefs
1180 AC_DEFINE(_LARGEFILE_SOURCE, 1,
1181 [This must be defined on some systems to enable large file support.])
1182 AC_DEFINE(_FILE_OFFSET_BITS, 64,
1183 [This must be set to 64 on some systems to enable large file support.])
1184 fi
1186 # Add some code to confdefs.h so that the test for off_t works on SCO
1187 cat >> confdefs.h <<\EOF
1188 #if defined(SCO_DS)
1189 #undef _OFF_T
1190 #endif
1191 EOF
1193 # Type availability checks
1194 AC_TYPE_MODE_T
1195 AC_TYPE_OFF_T
1196 AC_TYPE_PID_T
1197 AC_TYPE_SIGNAL
1198 AC_TYPE_SIZE_T
1199 AC_TYPE_UID_T
1200 AC_CHECK_TYPE(ssize_t,
1201 AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,)
1203 # Sizes of various common basic types
1204 # ANSI C requires sizeof(char) == 1, so no need to check it
1205 AC_CHECK_SIZEOF(int, 4)
1206 AC_CHECK_SIZEOF(long, 4)
1207 AC_CHECK_SIZEOF(void *, 4)
1208 AC_CHECK_SIZEOF(short, 2)
1209 AC_CHECK_SIZEOF(float, 4)
1210 AC_CHECK_SIZEOF(double, 8)
1211 AC_CHECK_SIZEOF(fpos_t, 4)
1212 AC_CHECK_SIZEOF(size_t, 4)
1214 AC_MSG_CHECKING(for long long support)
1215 have_long_long=no
1216 AC_TRY_COMPILE([], [long long x; x = (long long)0;], [
1217 AC_DEFINE(HAVE_LONG_LONG, 1, [Define this if you have the type long long.])
1218 have_long_long=yes
1219 ])
1220 AC_MSG_RESULT($have_long_long)
1221 if test "$have_long_long" = yes ; then
1222 AC_CHECK_SIZEOF(long long, 8)
1223 fi
1225 AC_MSG_CHECKING(for _Bool support)
1226 have_c99_bool=no
1227 AC_TRY_COMPILE([], [_Bool x; x = (_Bool)0;], [
1228 AC_DEFINE(HAVE_C99_BOOL, 1, [Define this if you have the type _Bool.])
1229 have_c99_bool=yes
1230 ])
1231 AC_MSG_RESULT($have_c99_bool)
1232 if test "$have_c99_bool" = yes ; then
1233 AC_CHECK_SIZEOF(_Bool, 1)
1234 fi
1236 AC_CHECK_TYPES(uintptr_t,
1237 [AC_CHECK_SIZEOF(uintptr_t, 4)],
1238 [], [#ifdef HAVE_STDINT_H
1239 #include <stdint.h>
1240 #endif])
1243 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
1244 AC_MSG_CHECKING(size of off_t)
1245 AC_CACHE_VAL(ac_cv_sizeof_off_t,
1246 [AC_TRY_RUN([#include <stdio.h>
1247 #include <sys/types.h>
1248 main()
1249 {
1250 FILE *f=fopen("conftestval", "w");
1251 if (!f) exit(1);
1252 fprintf(f, "%d\n", sizeof(off_t));
1253 exit(0);
1254 }],
1255 ac_cv_sizeof_off_t=`cat conftestval`,
1256 ac_cv_sizeof_off_t=0,
1257 ac_cv_sizeof_off_t=4)
1258 ])
1259 AC_MSG_RESULT($ac_cv_sizeof_off_t)
1260 AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t,
1261 [The number of bytes in an off_t.])
1263 AC_MSG_CHECKING(whether to enable large file support)
1264 if test "$have_long_long" = yes -a \
1265 "$ac_cv_sizeof_off_t" -gt "$ac_cv_sizeof_long" -a \
1266 "$ac_cv_sizeof_long_long" -ge "$ac_cv_sizeof_off_t"; then
1267 AC_DEFINE(HAVE_LARGEFILE_SUPPORT, 1,
1268 [Defined to enable large file support when an off_t is bigger than a long
1269 and long long is available and at least as big as an off_t. You may need
1270 to add some flags for configuration and compilation to enable this mode.
1271 (For Solaris and Linux, the necessary defines are already defined.)])
1272 AC_MSG_RESULT(yes)
1273 else
1274 AC_MSG_RESULT(no)
1275 fi
1277 # AC_CHECK_SIZEOF() doesn't include <time.h>.
1278 AC_MSG_CHECKING(size of time_t)
1279 AC_CACHE_VAL(ac_cv_sizeof_time_t,
1280 [AC_TRY_RUN([#include <stdio.h>
1281 #include <time.h>
1282 main()
1283 {
1284 FILE *f=fopen("conftestval", "w");
1285 if (!f) exit(1);
1286 fprintf(f, "%d\n", sizeof(time_t));
1287 exit(0);
1288 }],
1289 ac_cv_sizeof_time_t=`cat conftestval`,
1290 ac_cv_sizeof_time_t=0,
1291 ac_cv_sizeof_time_t=4)
1292 ])
1293 AC_MSG_RESULT($ac_cv_sizeof_time_t)
1294 AC_DEFINE_UNQUOTED(SIZEOF_TIME_T, $ac_cv_sizeof_time_t,
1295 [The number of bytes in a time_t.])
1298 # if have pthread_t then define SIZEOF_PTHREAD_T
1299 ac_save_cc="$CC"
1300 if test "$ac_cv_kpthread" = "yes"
1301 then CC="$CC -Kpthread"
1302 elif test "$ac_cv_kthread" = "yes"
1303 then CC="$CC -Kthread"
1304 elif test "$ac_cv_pthread" = "yes"
1305 then CC="$CC -pthread"
1306 fi
1307 AC_MSG_CHECKING(for pthread_t)
1308 have_pthread_t=no
1309 AC_TRY_COMPILE([#include <pthread.h>], [pthread_t x; x = *(pthread_t*)0;], have_pthread_t=yes)
1310 AC_MSG_RESULT($have_pthread_t)
1311 if test "$have_pthread_t" = yes ; then
1312 # AC_CHECK_SIZEOF() doesn't include <pthread.h>.
1313 AC_MSG_CHECKING(size of pthread_t)
1314 AC_CACHE_VAL(ac_cv_sizeof_pthread_t,
1315 [AC_TRY_RUN([#include <stdio.h>
1316 #include <pthread.h>
1317 main()
1318 {
1319 FILE *f=fopen("conftestval", "w");
1320 if (!f) exit(1);
1321 fprintf(f, "%d\n", sizeof(pthread_t));
1322 exit(0);
1323 }],
1324 ac_cv_sizeof_pthread_t=`cat conftestval`,
1325 ac_cv_sizeof_pthread_t=0,
1326 ac_cv_sizeof_pthread_t=4)
1327 ])
1328 AC_MSG_RESULT($ac_cv_sizeof_pthread_t)
1329 AC_DEFINE_UNQUOTED(SIZEOF_PTHREAD_T, $ac_cv_sizeof_pthread_t,
1330 [The number of bytes in a pthread_t.])
1331 fi
1332 CC="$ac_save_cc"
1334 AC_MSG_CHECKING(for --enable-toolbox-glue)
1335 AC_ARG_ENABLE(toolbox-glue,
1336 AC_HELP_STRING(--enable-toolbox-glue, disable/enable MacOSX glue code for extensions))
1338 if test -z "$enable_toolbox_glue"
1339 then
1340 case $ac_sys_system/$ac_sys_release in
1341 Darwin/*)
1342 enable_toolbox_glue="yes";;
1343 *)
1344 enable_toolbox_glue="no";;
1345 esac
1346 fi
1347 case "$enable_toolbox_glue" in
1348 yes)
1349 extra_machdep_objs="Python/mactoolboxglue.o"
1350 extra_undefs="-u _PyMac_Error"
1351 AC_DEFINE(USE_TOOLBOX_OBJECT_GLUE, 1,
1352 [Define if you want to use MacPython modules on MacOSX in unix-Python.])
1353 ;;
1354 *)
1355 extra_machdep_objs=""
1356 extra_undefs=""
1357 ;;
1358 esac
1359 AC_MSG_RESULT($enable_toolbox_glue)
1361 AC_SUBST(OTHER_LIBTOOL_OPT)
1362 case $ac_sys_system/$ac_sys_release in
1363 Darwin/@<:@01567@:>@\..*)
1364 OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
1365 ;;
1366 Darwin/*)
1367 OTHER_LIBTOOL_OPT=""
1368 ;;
1369 esac
1371 AC_SUBST(LIBTOOL_CRUFT)
1372 case $ac_sys_system/$ac_sys_release in
1373 Darwin/@<:@01567@:>@\..*)
1374 LIBTOOL_CRUFT="-framework System -lcc_dynamic"
1375 if test "${enable_universalsdk}"; then
1376 :
1377 else
1378 LIBTOOL_CRUFT="${LIBTOOL_CRUFT} -arch_only `arch`"
1379 fi
1380 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1381 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1382 Darwin/*)
1383 gcc_version=`gcc -v 2>&1 | grep version | cut -d\ -f3`
1384 if test ${gcc_version} '<' 4.0
1385 then
1386 LIBTOOL_CRUFT="-lcc_dynamic"
1387 else
1388 LIBTOOL_CRUFT=""
1389 fi
1390 LIBTOOL_CRUFT=$LIBTOOL_CRUFT" -lSystem -lSystemStubs -arch_only `arch`"
1391 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -install_name $(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1392 LIBTOOL_CRUFT=$LIBTOOL_CRUFT' -compatibility_version $(VERSION) -current_version $(VERSION)';;
1393 esac
1395 AC_MSG_CHECKING(for --enable-framework)
1396 if test "$enable_framework"
1397 then
1398 BASECFLAGS="$BASECFLAGS -fno-common -dynamic"
1399 # -F. is needed to allow linking to the framework while
1400 # in the build location.
1401 AC_DEFINE(WITH_NEXT_FRAMEWORK, 1,
1402 [Define if you want to produce an OpenStep/Rhapsody framework
1403 (shared library plus accessory files).])
1404 AC_MSG_RESULT(yes)
1405 else
1406 AC_MSG_RESULT(no)
1407 fi
1409 AC_MSG_CHECKING(for dyld)
1410 case $ac_sys_system/$ac_sys_release in
1411 Darwin/*)
1412 AC_DEFINE(WITH_DYLD, 1,
1413 [Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
1414 dynamic linker (dyld) instead of the old-style (NextStep) dynamic
1415 linker (rld). Dyld is necessary to support frameworks.])
1416 AC_MSG_RESULT(always on for Darwin)
1417 ;;
1418 *)
1419 AC_MSG_RESULT(no)
1420 ;;
1421 esac
1423 # Set info about shared libraries.
1424 AC_SUBST(SO)
1425 AC_SUBST(LDSHARED)
1426 AC_SUBST(BLDSHARED)
1427 AC_SUBST(CCSHARED)
1428 AC_SUBST(LINKFORSHARED)
1429 # SO is the extension of shared libraries `(including the dot!)
1430 # -- usually .so, .sl on HP-UX, .dll on Cygwin
1431 AC_MSG_CHECKING(SO)
1432 if test -z "$SO"
1433 then
1434 case $ac_sys_system in
1435 hp*|HP*)
1436 case `uname -m` in
1437 ia64) SO=.so;;
1438 *) SO=.sl;;
1439 esac
1440 ;;
1441 CYGWIN*) SO=.dll;;
1442 *) SO=.so;;
1443 esac
1444 else
1445 # this might also be a termcap variable, see #610332
1446 echo
1447 echo '====================================================================='
1448 echo '+ +'
1449 echo '+ WARNING: You have set SO in your environment. +'
1450 echo '+ Do you really mean to change the extension for shared libraries? +'
1451 echo '+ Continuing in 10 seconds to let you to ponder. +'
1452 echo '+ +'
1453 echo '====================================================================='
1454 sleep 10
1455 fi
1456 AC_MSG_RESULT($SO)
1457 AC_DEFINE_UNQUOTED(SHLIB_EXT, "$SO", [Define this to be extension of shared libraries (including the dot!).])
1458 # LDSHARED is the ld *command* used to create shared library
1459 # -- "cc -G" on SunOS 5.x, "ld -shared" on IRIX 5
1460 # (Shared libraries in this instance are shared modules to be loaded into
1461 # Python, as opposed to building Python itself as a shared library.)
1462 AC_MSG_CHECKING(LDSHARED)
1463 if test -z "$LDSHARED"
1464 then
1465 case $ac_sys_system/$ac_sys_release in
1466 AIX*)
1467 BLDSHARED="\$(srcdir)/Modules/ld_so_aix \$(CC) -bI:Modules/python.exp"
1468 LDSHARED="\$(BINLIBDEST)/config/ld_so_aix \$(CC) -bI:\$(BINLIBDEST)/config/python.exp"
1469 ;;
1470 BeOS*)
1471 BLDSHARED="\$(srcdir)/Modules/ld_so_beos $LDLIBRARY"
1472 LDSHARED="\$(BINLIBDEST)/config/ld_so_beos \$(LIBDIR)/$LDLIBRARY"
1473 ;;
1474 IRIX/5*) LDSHARED="ld -shared";;
1475 IRIX*/6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
1476 SunOS/5*)
1477 if test "$GCC" = "yes"
1478 then LDSHARED='$(CC) -shared'
1479 else LDSHARED='$(CC) -G';
1480 fi ;;
1481 hp*|HP*) LDSHARED="ld -b";;
1482 OSF*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
1483 Darwin/1.3*)
1484 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1485 if test "$enable_framework" ; then
1486 # Link against the framework. All externals should be defined.
1487 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1488 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1489 else
1490 # No framework. Ignore undefined symbols, assuming they come from Python
1491 LDSHARED="$LDSHARED -undefined suppress"
1492 fi ;;
1493 Darwin/1.4*|Darwin/5.*|Darwin/6.*)
1494 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1495 if test "$enable_framework" ; then
1496 # Link against the framework. All externals should be defined.
1497 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1498 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1499 else
1500 # No framework, use the Python app as bundle-loader
1501 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1502 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1503 fi ;;
1504 Darwin/*)
1505 # Use -undefined dynamic_lookup whenever possible (10.3 and later).
1506 # This allows an extension to be used in any Python
1507 cur_target=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
1508 if test ${cur_target} '>' 10.2; then
1509 cur_target=10.3
1510 fi
1511 CONFIGURE_MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET-${cur_target}}
1513 # Make sure that MACOSX_DEPLOYMENT_TARGET is set in the
1514 # environment with a value that is the same as what we'll use
1515 # in the Makefile to ensure that we'll get the same compiler
1516 # environment during configure and build time.
1517 MACOSX_DEPLOYMENT_TARGET="$CONFIGURE_MACOSX_DEPLOYMENT_TARGET"
1518 export MACOSX_DEPLOYMENT_TARGET
1520 EXPORT_MACOSX_DEPLOYMENT_TARGET=''
1521 if test ${MACOSX_DEPLOYMENT_TARGET-${cur_target}} '>' 10.2
1522 then
1523 if test "${enable_universalsdk}"; then
1524 LDFLAGS="-arch i386 -arch ppc -isysroot ${UNIVERSALSDK} ${LDFLAGS}"
1525 fi
1526 LDSHARED='$(CC) $(LDFLAGS) -bundle -undefined dynamic_lookup'
1527 BLDSHARED="$LDSHARED"
1528 else
1529 LDSHARED='$(CC) $(LDFLAGS) -bundle'
1530 if test "$enable_framework" ; then
1531 # Link against the framework. All externals should be defined.
1532 BLDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1533 LDSHARED="$LDSHARED "'$(PYTHONFRAMEWORKPREFIX)/$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1534 else
1535 # No framework, use the Python app as bundle-loader
1536 BLDSHARED="$LDSHARED "'-bundle_loader $(BUILDPYTHON)'
1537 LDSHARED="$LDSHARED "'-bundle_loader $(BINDIR)/python$(VERSION)$(EXE)'
1538 fi
1539 fi
1540 ;;
1541 Linux*|GNU*) LDSHARED='$(CC) -shared';;
1542 BSD/OS*/4*) LDSHARED="gcc -shared";;
1543 FreeBSD*)
1544 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1545 then
1546 LDSHARED="$CC -shared ${LDFLAGS}"
1547 else
1548 LDSHARED="ld -Bshareable ${LDFLAGS}"
1549 fi;;
1550 OpenBSD*)
1551 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1552 then
1553 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1554 else
1555 case `uname -r` in
1556 [[01]].* | 2.[[0-7]] | 2.[[0-7]].*)
1557 LDSHARED="ld -Bshareable ${LDFLAGS}"
1558 ;;
1559 *)
1560 LDSHARED='$(CC) -shared $(CCSHARED) ${LDFLAGS}'
1561 ;;
1562 esac
1563 fi;;
1564 NetBSD*|DragonFly*) LDSHARED="cc -shared ${LDFLAGS}";;
1565 OpenUNIX*|UnixWare*)
1566 if test "$GCC" = "yes"
1567 then LDSHARED='$(CC) -shared'
1568 else LDSHARED='$(CC) -G'
1569 fi;;
1570 SCO_SV*) LDSHARED='$(CC) -Wl,-G,-Bexport';;
1571 Monterey*) LDSHARED="cc -G -dy -Bdynamic -Bexport -L/usr/lib/ia64l64";;
1572 CYGWIN*) LDSHARED="gcc -shared -Wl,--enable-auto-image-base";;
1573 atheos*) LDSHARED="gcc -shared";;
1574 *) LDSHARED="ld";;
1575 esac
1576 fi
1577 AC_MSG_RESULT($LDSHARED)
1578 BLDSHARED=${BLDSHARED-$LDSHARED}
1579 # CCSHARED are the C *flags* used to create objects to go into a shared
1580 # library (module) -- this is only needed for a few systems
1581 AC_MSG_CHECKING(CCSHARED)
1582 if test -z "$CCSHARED"
1583 then
1584 case $ac_sys_system/$ac_sys_release in
1585 SunOS*) if test "$GCC" = yes;
1586 then CCSHARED="-fPIC";
1587 elif test `uname -p` = sparc;
1588 then CCSHARED="-xcode=pic32";
1589 else CCSHARED="-Kpic";
1590 fi;;
1591 hp*|HP*) if test "$GCC" = yes;
1592 then CCSHARED="-fPIC";
1593 else CCSHARED="+z";
1594 fi;;
1595 Linux*|GNU*) CCSHARED="-fPIC";;
1596 BSD/OS*/4*) CCSHARED="-fpic";;
1597 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
1598 OpenUNIX*|UnixWare*)
1599 if test "$GCC" = "yes"
1600 then CCSHARED="-fPIC"
1601 else CCSHARED="-KPIC"
1602 fi;;
1603 SCO_SV*)
1604 if test "$GCC" = "yes"
1605 then CCSHARED="-fPIC"
1606 else CCSHARED="-Kpic -belf"
1607 fi;;
1608 Monterey*) CCSHARED="-G";;
1609 IRIX*/6*) case $CC in
1610 *gcc*) CCSHARED="-shared";;
1611 *) CCSHARED="";;
1612 esac;;
1613 atheos*) CCSHARED="-fPIC";;
1614 esac
1615 fi
1616 AC_MSG_RESULT($CCSHARED)
1617 # LINKFORSHARED are the flags passed to the $(CC) command that links
1618 # the python executable -- this is only needed for a few systems
1619 AC_MSG_CHECKING(LINKFORSHARED)
1620 if test -z "$LINKFORSHARED"
1621 then
1622 case $ac_sys_system/$ac_sys_release in
1623 AIX*) LINKFORSHARED='-Wl,-bE:Modules/python.exp -lld';;
1624 hp*|HP*)
1625 LINKFORSHARED="-Wl,-E -Wl,+s";;
1626 # LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
1627 BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
1628 Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
1629 # -u libsys_s pulls in all symbols in libsys
1630 Darwin/*)
1631 # -u _PyMac_Error is needed to pull in the mac toolbox glue,
1632 # which is
1633 # not used by the core itself but which needs to be in the core so
1634 # that dynamically loaded extension modules have access to it.
1635 # -prebind is no longer used, because it actually seems to give a
1636 # slowdown in stead of a speedup, maybe due to the large number of
1637 # dynamic loads Python does.
1639 LINKFORSHARED="$extra_undefs"
1640 if test "$enable_framework"
1641 then
1642 LINKFORSHARED="$LINKFORSHARED "'$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK)'
1643 fi
1644 LINKFORSHARED="$LINKFORSHARED";;
1645 OpenUNIX*|UnixWare*) LINKFORSHARED="-Wl,-Bexport";;
1646 SCO_SV*) LINKFORSHARED="-Wl,-Bexport";;
1647 ReliantUNIX*) LINKFORSHARED="-W1 -Blargedynsym";;
1648 FreeBSD*|NetBSD*|OpenBSD*|DragonFly*)
1649 if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
1650 then
1651 LINKFORSHARED="-Wl,--export-dynamic"
1652 fi;;
1653 SunOS/5*) case $CC in
1654 *gcc*)
1655 if $CC -Xlinker --help 2>&1 | grep export-dynamic >/dev/null
1656 then
1657 LINKFORSHARED="-Xlinker --export-dynamic"
1658 fi;;
1659 esac;;
1660 CYGWIN*)
1661 if test $enable_shared = "no"
1662 then
1663 LINKFORSHARED='-Wl,--out-implib=$(LDLIBRARY)'
1664 fi;;
1665 esac
1666 fi
1667 AC_MSG_RESULT($LINKFORSHARED)
1669 AC_SUBST(CFLAGSFORSHARED)
1670 AC_MSG_CHECKING(CFLAGSFORSHARED)
1671 if test ! "$LIBRARY" = "$LDLIBRARY"
1672 then
1673 case $ac_sys_system in
1674 CYGWIN*)
1675 # Cygwin needs CCSHARED when building extension DLLs
1676 # but not when building the interpreter DLL.
1677 CFLAGSFORSHARED='';;
1678 *)
1679 CFLAGSFORSHARED='$(CCSHARED)'
1680 esac
1681 fi
1682 AC_MSG_RESULT($CFLAGSFORSHARED)
1684 # SHLIBS are libraries (except -lc and -lm) to link to the python shared
1685 # library (with --enable-shared).
1686 # For platforms on which shared libraries are not allowed to have unresolved
1687 # symbols, this must be set to $(LIBS) (expanded by make). We do this even
1688 # if it is not required, since it creates a dependency of the shared library
1689 # to LIBS. This, in turn, means that applications linking the shared libpython
1690 # don't need to link LIBS explicitly. The default should be only changed
1691 # on systems where this approach causes problems.
1692 AC_SUBST(SHLIBS)
1693 AC_MSG_CHECKING(SHLIBS)
1694 case "$ac_sys_system" in
1695 *)
1696 SHLIBS='$(LIBS)';;
1697 esac
1698 AC_MSG_RESULT($SHLIBS)
1701 # checks for libraries
1702 AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
1703 AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
1705 # only check for sem_ini if thread support is requested
1706 if test "$with_threads" = "yes" -o -z "$with_threads"; then
1707 AC_SEARCH_LIBS(sem_init, pthread rt posix4) # 'Real Time' functions on Solaris
1708 # posix4 on Solaris 2.6
1709 # pthread (first!) on Linux
1710 fi
1712 # check if we need libintl for locale functions
1713 AC_CHECK_LIB(intl, textdomain,
1714 AC_DEFINE(WITH_LIBINTL, 1,
1715 [Define to 1 if libintl is needed for locale functions.]))
1717 # checks for system dependent C++ extensions support
1718 case "$ac_sys_system" in
1719 AIX*) AC_MSG_CHECKING(for genuine AIX C++ extensions support)
1720 AC_TRY_LINK([#include "/usr/lpp/xlC/include/load.h"],
1721 [loadAndInit("", 0, "")],
1722 [AC_DEFINE(AIX_GENUINE_CPLUSPLUS, 1,
1723 [Define for AIX if your compiler is a genuine IBM xlC/xlC_r
1724 and you want support for AIX C++ shared extension modules.])
1725 AC_MSG_RESULT(yes)],
1726 [AC_MSG_RESULT(no)]);;
1727 *) ;;
1728 esac
1730 # Most SVR4 platforms (e.g. Solaris) need -lsocket and -lnsl.
1731 # BeOS' sockets are stashed in libnet.
1732 AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
1733 AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
1735 case "$ac_sys_system" in
1736 BeOS*)
1737 AC_CHECK_LIB(net, socket, [LIBS="-lnet $LIBS"], [], $LIBS) # BeOS
1738 ;;
1739 esac
1741 AC_MSG_CHECKING(for --with-libs)
1742 AC_ARG_WITH(libs,
1743 AC_HELP_STRING(--with-libs='lib1 ...', link against additional libs),
1744 [
1745 AC_MSG_RESULT($withval)
1746 LIBS="$withval $LIBS"
1747 ],
1748 [AC_MSG_RESULT(no)])
1750 # Check for use of the system libffi library
1751 AC_MSG_CHECKING(for --with-system-ffi)
1752 AC_ARG_WITH(system_ffi,
1753 AC_HELP_STRING(--with-system-ffi, build _ctypes module using an installed ffi library))
1755 if test -z "$with_system_ffi"
1756 then with_system_ffi="no"
1757 fi
1758 AC_MSG_RESULT($with_system_ffi)
1760 # Determine if signalmodule should be used.
1761 AC_SUBST(USE_SIGNAL_MODULE)
1762 AC_SUBST(SIGNAL_OBJS)
1763 AC_MSG_CHECKING(for --with-signal-module)
1764 AC_ARG_WITH(signal-module,
1765 AC_HELP_STRING(--with-signal-module, disable/enable signal module))
1767 if test -z "$with_signal_module"
1768 then with_signal_module="yes"
1769 fi
1770 AC_MSG_RESULT($with_signal_module)
1772 if test "${with_signal_module}" = "yes"; then
1773 USE_SIGNAL_MODULE=""
1774 SIGNAL_OBJS=""
1775 else
1776 USE_SIGNAL_MODULE="#"
1777 SIGNAL_OBJS="Parser/intrcheck.o Python/sigcheck.o"
1778 fi
1780 # This is used to generate Setup.config
1781 AC_SUBST(USE_THREAD_MODULE)
1782 USE_THREAD_MODULE=""
1784 AC_MSG_CHECKING(for --with-dec-threads)
1785 AC_SUBST(LDLAST)
1786 AC_ARG_WITH(dec-threads,
1787 AC_HELP_STRING(--with-dec-threads, use DEC Alpha/OSF1 thread-safe libraries),
1788 [
1789 AC_MSG_RESULT($withval)
1790 LDLAST=-threads
1791 if test "${with_thread+set}" != set; then
1792 with_thread="$withval";
1793 fi],
1794 [AC_MSG_RESULT(no)])
1796 # Templates for things AC_DEFINEd more than once.
1797 # For a single AC_DEFINE, no template is needed.
1798 AH_TEMPLATE(C_THREADS,[Define if you have the Mach cthreads package])
1799 AH_TEMPLATE(_REENTRANT,
1800 [Define to force use of thread-safe errno, h_errno, and other functions])
1801 AH_TEMPLATE(WITH_THREAD,
1802 [Define if you want to compile in rudimentary thread support])
1804 AC_MSG_CHECKING(for --with-threads)
1805 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1806 AC_ARG_WITH(threads,
1807 AC_HELP_STRING(--with(out)-threads@<:@=DIRECTORY@:>@, disable/enable thread support))
1809 # --with-thread is deprecated, but check for it anyway
1810 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
1811 AC_ARG_WITH(thread,
1812 AC_HELP_STRING(--with(out)-thread@<:@=DIRECTORY@:>@, deprecated; use --with(out)-threads),
1813 [with_threads=$with_thread])
1815 if test -z "$with_threads"
1816 then with_threads="yes"
1817 fi
1818 AC_MSG_RESULT($with_threads)
1820 AC_SUBST(THREADOBJ)
1821 if test "$with_threads" = "no"
1822 then
1823 USE_THREAD_MODULE="#"
1824 elif test "$ac_cv_pthread_is_default" = yes
1825 then
1826 AC_DEFINE(WITH_THREAD)
1827 # Defining _REENTRANT on system with POSIX threads should not hurt.
1828 AC_DEFINE(_REENTRANT)
1829 posix_threads=yes
1830 THREADOBJ="Python/thread.o"
1831 elif test "$ac_cv_kpthread" = "yes"
1832 then
1833 CC="$CC -Kpthread"
1834 if test "$ac_cv_cxx_thread" = "yes"; then
1835 CXX="$CXX -Kpthread"
1836 fi
1837 AC_DEFINE(WITH_THREAD)
1838 posix_threads=yes
1839 THREADOBJ="Python/thread.o"
1840 elif test "$ac_cv_kthread" = "yes"
1841 then
1842 CC="$CC -Kthread"
1843 if test "$ac_cv_cxx_thread" = "yes"; then
1844 CXX="$CXX -Kthread"
1845 fi
1846 AC_DEFINE(WITH_THREAD)
1847 posix_threads=yes
1848 THREADOBJ="Python/thread.o"
1849 elif test "$ac_cv_pthread" = "yes"
1850 then
1851 CC="$CC -pthread"
1852 if test "$ac_cv_cxx_thread" = "yes"; then
1853 CXX="$CXX -pthread"
1854 fi
1855 AC_DEFINE(WITH_THREAD)
1856 posix_threads=yes
1857 THREADOBJ="Python/thread.o"
1858 else
1859 if test ! -z "$with_threads" -a -d "$with_threads"
1860 then LDFLAGS="$LDFLAGS -L$with_threads"
1861 fi
1862 if test ! -z "$withval" -a -d "$withval"
1863 then LDFLAGS="$LDFLAGS -L$withval"
1864 fi
1866 # According to the POSIX spec, a pthreads implementation must
1867 # define _POSIX_THREADS in unistd.h. Some apparently don't
1868 # (e.g. gnu pth with pthread emulation)
1869 AC_MSG_CHECKING(for _POSIX_THREADS in unistd.h)
1870 AC_EGREP_CPP(yes,
1871 [
1872 #include <unistd.h>
1873 #ifdef _POSIX_THREADS
1874 yes
1875 #endif
1876 ], unistd_defines_pthreads=yes, unistd_defines_pthreads=no)
1877 AC_MSG_RESULT($unistd_defines_pthreads)
1879 AC_DEFINE(_REENTRANT)
1880 AC_CHECK_HEADER(cthreads.h, [AC_DEFINE(WITH_THREAD)
1881 AC_DEFINE(C_THREADS)
1882 AC_DEFINE(HURD_C_THREADS, 1,
1883 [Define if you are using Mach cthreads directly under /include])
1884 LIBS="$LIBS -lthreads"
1885 THREADOBJ="Python/thread.o"],[
1886 AC_CHECK_HEADER(mach/cthreads.h, [AC_DEFINE(WITH_THREAD)
1887 AC_DEFINE(C_THREADS)
1888 AC_DEFINE(MACH_C_THREADS, 1,
1889 [Define if you are using Mach cthreads under mach /])
1890 THREADOBJ="Python/thread.o"],[
1891 AC_MSG_CHECKING(for --with-pth)
1892 AC_ARG_WITH([pth],
1893 AC_HELP_STRING(--with-pth, use GNU pth threading libraries),
1894 [AC_MSG_RESULT($withval)
1895 AC_DEFINE([WITH_THREAD])
1896 AC_DEFINE([HAVE_PTH], 1,
1897 [Define if you have GNU PTH threads.])
1898 LIBS="-lpth $LIBS"
1899 THREADOBJ="Python/thread.o"],
1900 [AC_MSG_RESULT(no)
1902 # Just looking for pthread_create in libpthread is not enough:
1903 # on HP/UX, pthread.h renames pthread_create to a different symbol name.
1904 # So we really have to include pthread.h, and then link.
1905 _libs=$LIBS
1906 LIBS="$LIBS -lpthread"
1907 AC_MSG_CHECKING([for pthread_create in -lpthread])
1908 AC_TRY_LINK([#include <pthread.h>
1910 void * start_routine (void *arg) { exit (0); }], [
1911 pthread_create (NULL, NULL, start_routine, NULL)], [
1912 AC_MSG_RESULT(yes)
1913 AC_DEFINE(WITH_THREAD)
1914 posix_threads=yes
1915 THREADOBJ="Python/thread.o"],[
1916 LIBS=$_libs
1917 AC_CHECK_FUNC(pthread_detach, [AC_DEFINE(WITH_THREAD)
1918 posix_threads=yes
1919 THREADOBJ="Python/thread.o"],[
1920 AC_CHECK_HEADER(atheos/threads.h, [AC_DEFINE(WITH_THREAD)
1921 AC_DEFINE(ATHEOS_THREADS, 1,
1922 [Define this if you have AtheOS threads.])
1923 THREADOBJ="Python/thread.o"],[
1924 AC_CHECK_HEADER(kernel/OS.h, [AC_DEFINE(WITH_THREAD)
1925 AC_DEFINE(BEOS_THREADS, 1,
1926 [Define this if you have BeOS threads.])
1927 THREADOBJ="Python/thread.o"],[
1928 AC_CHECK_LIB(pthreads, pthread_create, [AC_DEFINE(WITH_THREAD)
1929 posix_threads=yes
1930 LIBS="$LIBS -lpthreads"
1931 THREADOBJ="Python/thread.o"], [
1932 AC_CHECK_LIB(c_r, pthread_create, [AC_DEFINE(WITH_THREAD)
1933 posix_threads=yes
1934 LIBS="$LIBS -lc_r"
1935 THREADOBJ="Python/thread.o"], [
1936 AC_CHECK_LIB(pthread, __pthread_create_system, [AC_DEFINE(WITH_THREAD)
1937 posix_threads=yes
1938 LIBS="$LIBS -lpthread"
1939 THREADOBJ="Python/thread.o"], [
1940 AC_CHECK_LIB(cma, pthread_create, [AC_DEFINE(WITH_THREAD)
1941 posix_threads=yes
1942 LIBS="$LIBS -lcma"
1943 THREADOBJ="Python/thread.o"],[
1944 USE_THREAD_MODULE="#"])
1945 ])])])])])])])])])])
1947 AC_CHECK_LIB(mpc, usconfig, [AC_DEFINE(WITH_THREAD)
1948 LIBS="$LIBS -lmpc"
1949 THREADOBJ="Python/thread.o"
1950 USE_THREAD_MODULE=""])
1952 if test "$posix_threads" != "yes"; then
1953 AC_CHECK_LIB(thread, thr_create, [AC_DEFINE(WITH_THREAD)
1954 LIBS="$LIBS -lthread"
1955 THREADOBJ="Python/thread.o"
1956 USE_THREAD_MODULE=""])
1957 fi
1959 if test "$USE_THREAD_MODULE" != "#"
1960 then
1961 # If the above checks didn't disable threads, (at least) OSF1
1962 # needs this '-threads' argument during linking.
1963 case $ac_sys_system in
1964 OSF1) LDLAST=-threads;;
1965 esac
1966 fi
1967 fi
1969 if test "$posix_threads" = "yes"; then
1970 if test "$unistd_defines_pthreads" = "no"; then
1971 AC_DEFINE(_POSIX_THREADS, 1,
1972 [Define if you have POSIX threads,
1973 and your system does not define that.])
1974 fi
1976 # Bug 662787: Using semaphores causes unexplicable hangs on Solaris 8.
1977 case $ac_sys_system/$ac_sys_release in
1978 SunOS/5.6) AC_DEFINE(HAVE_PTHREAD_DESTRUCTOR, 1,
1979 Defined for Solaris 2.6 bug in pthread header.)
1980 ;;
1981 SunOS/5.8) AC_DEFINE(HAVE_BROKEN_POSIX_SEMAPHORES, 1,
1982 Define if the Posix semaphores do not work on your system)
1983 ;;
1984 esac
1986 AC_MSG_CHECKING(if PTHREAD_SCOPE_SYSTEM is supported)
1987 AC_CACHE_VAL(ac_cv_pthread_system_supported,
1988 [AC_TRY_RUN([#include <pthread.h>
1989 void *foo(void *parm) {
1990 return NULL;
1991 }
1992 main() {
1993 pthread_attr_t attr;
1994 pthread_t id;
1995 if (pthread_attr_init(&attr)) exit(-1);
1996 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) exit(-1);
1997 if (pthread_create(&id, &attr, foo, NULL)) exit(-1);
1998 exit(0);
1999 }],
2000 ac_cv_pthread_system_supported=yes,
2001 ac_cv_pthread_system_supported=no,
2002 ac_cv_pthread_system_supported=no)
2003 ])
2004 AC_MSG_RESULT($ac_cv_pthread_system_supported)
2005 if test "$ac_cv_pthread_system_supported" = "yes"; then
2006 AC_DEFINE(PTHREAD_SYSTEM_SCHED_SUPPORTED, 1, [Defined if PTHREAD_SCOPE_SYSTEM supported.])
2007 fi
2008 AC_CHECK_FUNCS(pthread_sigmask,
2009 [case $ac_sys_system in
2010 CYGWIN*)
2011 AC_DEFINE(HAVE_BROKEN_PTHREAD_SIGMASK, 1,
2012 [Define if pthread_sigmask() does not work on your system.])
2013 ;;
2014 esac])
2015 fi
2018 # Check for enable-ipv6
2019 AH_TEMPLATE(ENABLE_IPV6, [Define if --enable-ipv6 is specified])
2020 AC_MSG_CHECKING([if --enable-ipv6 is specified])
2021 AC_ARG_ENABLE(ipv6,
2022 [ --enable-ipv6 Enable ipv6 (with ipv4) support
2023 --disable-ipv6 Disable ipv6 support],
2024 [ case "$enableval" in
2025 no)
2026 AC_MSG_RESULT(no)
2027 ipv6=no
2028 ;;
2029 *) AC_MSG_RESULT(yes)
2030 AC_DEFINE(ENABLE_IPV6)
2031 ipv6=yes
2032 ;;
2033 esac ],
2035 [
2036 dnl the check does not work on cross compilation case...
2037 AC_TRY_RUN([ /* AF_INET6 available check */
2038 #include <sys/types.h>
2039 #include <sys/socket.h>
2040 main()
2041 {
2042 if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
2043 exit(1);
2044 else
2045 exit(0);
2046 }
2047 ],
2048 AC_MSG_RESULT(yes)
2049 ipv6=yes,
2050 AC_MSG_RESULT(no)
2051 ipv6=no,
2052 AC_MSG_RESULT(no)
2053 ipv6=no
2054 )
2056 if test "$ipv6" = "yes"; then
2057 AC_MSG_CHECKING(if RFC2553 API is available)
2058 AC_TRY_COMPILE([#include <sys/types.h>
2059 #include <netinet/in.h>],
2060 [struct sockaddr_in6 x;
2061 x.sin6_scope_id;],
2062 AC_MSG_RESULT(yes)
2063 ipv6=yes,
2064 AC_MSG_RESULT(no, IPv6 disabled)
2065 ipv6=no)
2066 fi
2068 if test "$ipv6" = "yes"; then
2069 AC_DEFINE(ENABLE_IPV6)
2070 fi
2071 ])
2073 ipv6type=unknown
2074 ipv6lib=none
2075 ipv6trylibc=no
2077 if test "$ipv6" = "yes"; then
2078 AC_MSG_CHECKING([ipv6 stack type])
2079 for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta;
2080 do
2081 case $i in
2082 inria)
2083 dnl http://www.kame.net/
2084 AC_EGREP_CPP(yes, [
2085 #include <netinet/in.h>
2086 #ifdef IPV6_INRIA_VERSION
2087 yes
2088 #endif],
2089 [ipv6type=$i])
2090 ;;
2091 kame)
2092 dnl http://www.kame.net/
2093 AC_EGREP_CPP(yes, [
2094 #include <netinet/in.h>
2095 #ifdef __KAME__
2096 yes
2097 #endif],
2098 [ipv6type=$i;
2099 ipv6lib=inet6
2100 ipv6libdir=/usr/local/v6/lib
2101 ipv6trylibc=yes])
2102 ;;
2103 linux-glibc)
2104 dnl http://www.v6.linux.or.jp/
2105 AC_EGREP_CPP(yes, [
2106 #include <features.h>
2107 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2))
2108 yes
2109 #endif],
2110 [ipv6type=$i;
2111 ipv6trylibc=yes])
2112 ;;
2113 linux-inet6)
2114 dnl http://www.v6.linux.or.jp/
2115 if test -d /usr/inet6; then
2116 ipv6type=$i
2117 ipv6lib=inet6
2118 ipv6libdir=/usr/inet6/lib
2119 BASECFLAGS="-I/usr/inet6/include $BASECFLAGS"
2120 fi
2121 ;;
2122 solaris)
2123 if test -f /etc/netconfig; then
2124 if /usr/xpg4/bin/grep -q tcp6 /etc/netconfig; then
2125 ipv6type=$i
2126 ipv6trylibc=yes
2127 fi
2128 fi
2129 ;;
2130 toshiba)
2131 AC_EGREP_CPP(yes, [
2132 #include <sys/param.h>
2133 #ifdef _TOSHIBA_INET6
2134 yes
2135 #endif],
2136 [ipv6type=$i;
2137 ipv6lib=inet6;
2138 ipv6libdir=/usr/local/v6/lib])
2139 ;;
2140 v6d)
2141 AC_EGREP_CPP(yes, [
2142 #include </usr/local/v6/include/sys/v6config.h>
2143 #ifdef __V6D__
2144 yes
2145 #endif],
2146 [ipv6type=$i;
2147 ipv6lib=v6;
2148 ipv6libdir=/usr/local/v6/lib;
2149 BASECFLAGS="-I/usr/local/v6/include $BASECFLAGS"])
2150 ;;
2151 zeta)
2152 AC_EGREP_CPP(yes, [
2153 #include <sys/param.h>
2154 #ifdef _ZETA_MINAMI_INET6
2155 yes
2156 #endif],
2157 [ipv6type=$i;
2158 ipv6lib=inet6;
2159 ipv6libdir=/usr/local/v6/lib])
2160 ;;
2161 esac
2162 if test "$ipv6type" != "unknown"; then
2163 break
2164 fi
2165 done
2166 AC_MSG_RESULT($ipv6type)
2167 fi
2169 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
2170 if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
2171 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
2172 echo "using lib$ipv6lib"
2173 else
2174 if test $ipv6trylibc = "yes"; then
2175 echo "using libc"
2176 else
2177 echo 'Fatal: no $ipv6lib library found. cannot continue.'
2178 echo "You need to fetch lib$ipv6lib.a from appropriate"
2179 echo 'ipv6 kit and compile beforehand.'
2180 exit 1
2181 fi
2182 fi
2183 fi
2185 # Check for --with-doc-strings
2186 AC_MSG_CHECKING(for --with-doc-strings)
2187 AC_ARG_WITH(doc-strings,
2188 AC_HELP_STRING(--with(out)-doc-strings, disable/enable documentation strings))
2190 if test -z "$with_doc_strings"
2191 then with_doc_strings="yes"
2192 fi
2193 if test "$with_doc_strings" != "no"
2194 then
2195 AC_DEFINE(WITH_DOC_STRINGS, 1,
2196 [Define if you want documentation strings in extension modules])
2197 fi
2198 AC_MSG_RESULT($with_doc_strings)
2200 # Check for Python-specific malloc support
2201 AC_MSG_CHECKING(for --with-tsc)
2202 AC_ARG_WITH(tsc,
2203 [ --with(out)-tsc enable/disable timestamp counter profile], [
2204 if test "$withval" != no
2205 then
2206 AC_DEFINE(WITH_TSC, 1,
2207 [Define to profile with the Pentium timestamp counter])
2208 AC_MSG_RESULT(yes)
2209 else AC_MSG_RESULT(no)
2210 fi],
2211 [AC_MSG_RESULT(no)])
2213 # Check for Python-specific malloc support
2214 AC_MSG_CHECKING(for --with-pymalloc)
2215 AC_ARG_WITH(pymalloc,
2216 AC_HELP_STRING(--with(out)-pymalloc, disable/enable specialized mallocs))
2218 if test -z "$with_pymalloc"
2219 then with_pymalloc="yes"
2220 fi
2221 if test "$with_pymalloc" != "no"
2222 then
2223 AC_DEFINE(WITH_PYMALLOC, 1,
2224 [Define if you want to compile in Python-specific mallocs])
2225 fi
2226 AC_MSG_RESULT($with_pymalloc)
2228 # Check for --with-wctype-functions
2229 AC_MSG_CHECKING(for --with-wctype-functions)
2230 AC_ARG_WITH(wctype-functions,
2231 AC_HELP_STRING(--with-wctype-functions, use wctype.h functions),
2232 [
2233 if test "$withval" != no
2234 then
2235 AC_DEFINE(WANT_WCTYPE_FUNCTIONS, 1,
2236 [Define if you want wctype.h functions to be used instead of the
2237 one supplied by Python itself. (see Include/unicodectype.h).])
2238 AC_MSG_RESULT(yes)
2239 else AC_MSG_RESULT(no)
2240 fi],
2241 [AC_MSG_RESULT(no)])
2243 # -I${DLINCLDIR} is added to the compile rule for importdl.o
2244 AC_SUBST(DLINCLDIR)
2245 DLINCLDIR=.
2247 # the dlopen() function means we might want to use dynload_shlib.o. some
2248 # platforms, such as AIX, have dlopen(), but don't want to use it.
2249 AC_CHECK_FUNCS(dlopen)
2251 # DYNLOADFILE specifies which dynload_*.o file we will use for dynamic
2252 # loading of modules.
2253 AC_SUBST(DYNLOADFILE)
2254 AC_MSG_CHECKING(DYNLOADFILE)
2255 if test -z "$DYNLOADFILE"
2256 then
2257 case $ac_sys_system/$ac_sys_release in
2258 AIX*) # Use dynload_shlib.c and dlopen() if we have it; otherwise dynload_aix.c
2259 if test "$ac_cv_func_dlopen" = yes
2260 then DYNLOADFILE="dynload_shlib.o"
2261 else DYNLOADFILE="dynload_aix.o"
2262 fi
2263 ;;
2264 BeOS*) DYNLOADFILE="dynload_beos.o";;
2265 hp*|HP*) DYNLOADFILE="dynload_hpux.o";;
2266 # Use dynload_next.c only on 10.2 and below, which don't have native dlopen()
2267 Darwin/@<:@0156@:>@\..*) DYNLOADFILE="dynload_next.o";;
2268 atheos*) DYNLOADFILE="dynload_atheos.o";;
2269 *)
2270 # use dynload_shlib.c and dlopen() if we have it; otherwise stub
2271 # out any dynamic loading
2272 if test "$ac_cv_func_dlopen" = yes
2273 then DYNLOADFILE="dynload_shlib.o"
2274 else DYNLOADFILE="dynload_stub.o"
2275 fi
2276 ;;
2277 esac
2278 fi
2279 AC_MSG_RESULT($DYNLOADFILE)
2280 if test "$DYNLOADFILE" != "dynload_stub.o"
2281 then
2282 AC_DEFINE(HAVE_DYNAMIC_LOADING, 1,
2283 [Defined when any dynamic module loading is enabled.])
2284 fi
2286 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
2288 AC_SUBST(MACHDEP_OBJS)
2289 AC_MSG_CHECKING(MACHDEP_OBJS)
2290 if test -z "$MACHDEP_OBJS"
2291 then
2292 MACHDEP_OBJS=$extra_machdep_objs
2293 else
2294 MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
2295 fi
2296 AC_MSG_RESULT(MACHDEP_OBJS)
2298 # checks for library functions
2299 AC_CHECK_FUNCS(alarm bind_textdomain_codeset chflags chown clock confstr \
2300 ctermid execv fork fpathconf ftime ftruncate \
2301 gai_strerror getgroups getlogin getloadavg getpeername getpgid getpid \
2302 getpriority getpwent getspnam getspent getsid getwd \
2303 kill killpg lchflags lchown lstat mkfifo mknod mktime \
2304 mremap nice pathconf pause plock poll pthread_init \
2305 putenv readlink realpath \
2306 select setegid seteuid setgid \
2307 setlocale setregid setreuid setsid setpgid setpgrp setuid setvbuf snprintf \
2308 sigaction siginterrupt sigrelse strftime \
2309 sysconf tcgetpgrp tcsetpgrp tempnam timegm times tmpfile tmpnam tmpnam_r \
2310 truncate uname unsetenv utimes waitpid wait3 wait4 wcscoll _getpty)
2312 # For some functions, having a definition is not sufficient, since
2313 # we want to take their address.
2314 AC_MSG_CHECKING(for chroot)
2315 AC_TRY_COMPILE([#include <unistd.h>], void *x=chroot,
2316 AC_DEFINE(HAVE_CHROOT, 1, Define if you have the 'chroot' function.)
2317 AC_MSG_RESULT(yes),
2318 AC_MSG_RESULT(no)
2319 )
2320 AC_MSG_CHECKING(for link)
2321 AC_TRY_COMPILE([#include <unistd.h>], void *x=link,
2322 AC_DEFINE(HAVE_LINK, 1, Define if you have the 'link' function.)
2323 AC_MSG_RESULT(yes),
2324 AC_MSG_RESULT(no)
2325 )
2326 AC_MSG_CHECKING(for symlink)
2327 AC_TRY_COMPILE([#include <unistd.h>], void *x=symlink,
2328 AC_DEFINE(HAVE_SYMLINK, 1, Define if you have the 'symlink' function.)
2329 AC_MSG_RESULT(yes),
2330 AC_MSG_RESULT(no)
2331 )
2332 AC_MSG_CHECKING(for fchdir)
2333 AC_TRY_COMPILE([#include <unistd.h>], void *x=fchdir,
2334 AC_DEFINE(HAVE_FCHDIR, 1, Define if you have the 'fchdir' function.)
2335 AC_MSG_RESULT(yes),
2336 AC_MSG_RESULT(no)
2337 )
2338 AC_MSG_CHECKING(for fsync)
2339 AC_TRY_COMPILE([#include <unistd.h>], void *x=fsync,
2340 AC_DEFINE(HAVE_FSYNC, 1, Define if you have the 'fsync' function.)
2341 AC_MSG_RESULT(yes),
2342 AC_MSG_RESULT(no)
2343 )
2344 AC_MSG_CHECKING(for fdatasync)
2345 AC_TRY_COMPILE([#include <unistd.h>], void *x=fdatasync,
2346 AC_DEFINE(HAVE_FDATASYNC, 1, Define if you have the 'fdatasync' function.)
2347 AC_MSG_RESULT(yes),
2348 AC_MSG_RESULT(no)
2349 )
2351 # On some systems (eg. FreeBSD 5), we would find a definition of the
2352 # functions ctermid_r, setgroups in the library, but no prototype
2353 # (e.g. because we use _XOPEN_SOURCE). See whether we can take their
2354 # address to avoid compiler warnings and potential miscompilations
2355 # because of the missing prototypes.
2357 AC_MSG_CHECKING(for ctermid_r)
2358 AC_TRY_COMPILE([
2359 #include "confdefs.h"
2360 #include <stdio.h>
2361 ], void* p = ctermid_r,
2362 AC_DEFINE(HAVE_CTERMID_R, 1, Define if you have the 'ctermid_r' function.)
2363 AC_MSG_RESULT(yes),
2364 AC_MSG_RESULT(no)
2365 )
2367 AC_MSG_CHECKING(for flock)
2368 AC_TRY_COMPILE([
2369 #include "confdefs.h"
2370 #include <sys/file.h>
2371 ], void* p = flock,
2372 AC_DEFINE(HAVE_FLOCK, 1, Define if you have the 'flock' function.)
2373 AC_MSG_RESULT(yes),
2374 AC_MSG_RESULT(no)
2375 )
2377 AC_MSG_CHECKING(for getpagesize)
2378 AC_TRY_COMPILE([
2379 #include "confdefs.h"
2380 #include <unistd.h>
2381 ], void* p = getpagesize,
2382 AC_DEFINE(HAVE_GETPAGESIZE, 1, Define if you have the 'getpagesize' function.)
2383 AC_MSG_RESULT(yes),
2384 AC_MSG_RESULT(no)
2385 )
2387 dnl check for true
2388 AC_CHECK_PROGS(TRUE, true, /bin/true)
2390 dnl On some systems (e.g. Solaris 9), hstrerror and inet_aton are in -lresolv
2391 dnl On others, they are in the C library, so we to take no action
2392 AC_CHECK_LIB(c, inet_aton, [$ac_cv_prog_TRUE],
2393 AC_CHECK_LIB(resolv, inet_aton)
2394 )
2396 dnl Check if system zlib has *Copy() functions
2397 dnl
2398 dnl On MacOSX the linker will search for dylibs on the entire linker path
2399 dnl before searching for static libraries. setup.py adds -Wl,-search_paths_first
2400 dnl to revert to a more traditional unix behaviour and make it possible to
2401 dnl override the system libz with a local static library of libz. Temporarily
2402 dnl add that flag to our CFLAGS as well to ensure that we check the version
2403 dnl of libz that will be used by setup.py.
2404 dnl The -L/usr/local/lib is needed as wel to get the same compilation
2405 dnl environment as setup.py (and leaving it out can cause configure to use the
2406 dnl wrong version of the library)
2407 case $ac_sys_system/$ac_sys_release in
2408 Darwin/*)
2409 _CUR_CFLAGS="${CFLAGS}"
2410 _CUR_LDFLAGS="${LDFLAGS}"
2411 CFLAGS="${CFLAGS} -Wl,-search_paths_first"
2412 LDFLAGS="${LDFLAGS} -Wl,-search_paths_first -L/usr/local/lib"
2413 ;;
2414 esac
2416 AC_CHECK_LIB(z, inflateCopy, AC_DEFINE(HAVE_ZLIB_COPY, 1, Define if the zlib library has inflateCopy))
2418 case $ac_sys_system/$ac_sys_release in
2419 Darwin/*)
2420 CFLAGS="${_CUR_CFLAGS}"
2421 LDFLAGS="${_CUR_LDFLAGS}"
2422 ;;
2423 esac
2425 AC_MSG_CHECKING(for hstrerror)
2426 AC_TRY_LINK([
2427 #include "confdefs.h"
2428 #include <netdb.h>
2429 ], void* p = hstrerror; hstrerror(0),
2430 AC_DEFINE(HAVE_HSTRERROR, 1, Define if you have the 'hstrerror' function.)
2431 AC_MSG_RESULT(yes),
2432 AC_MSG_RESULT(no)
2433 )
2435 AC_MSG_CHECKING(for inet_aton)
2436 AC_TRY_LINK([
2437 #include "confdefs.h"
2438 #include <sys/types.h>
2439 #include <sys/socket.h>
2440 #include <netinet/in.h>
2441 #include <arpa/inet.h>
2442 ], void* p = inet_aton;inet_aton(0,0),
2443 AC_DEFINE(HAVE_INET_ATON, 1, Define if you have the 'inet_aton' function.)
2444 AC_MSG_RESULT(yes),
2445 AC_MSG_RESULT(no)
2446 )
2448 AC_MSG_CHECKING(for inet_pton)
2449 AC_TRY_COMPILE([
2450 #include "confdefs.h"
2451 #include <sys/types.h>
2452 #include <sys/socket.h>
2453 #include <netinet/in.h>
2454 #include <arpa/inet.h>
2455 ], void* p = inet_pton,
2456 AC_DEFINE(HAVE_INET_PTON, 1, Define if you have the 'inet_pton' function.)
2457 AC_MSG_RESULT(yes),
2458 AC_MSG_RESULT(no)
2459 )
2461 # On some systems, setgroups is in unistd.h, on others, in grp.h
2462 AC_MSG_CHECKING(for setgroups)
2463 AC_TRY_COMPILE([
2464 #include "confdefs.h"
2465 #include <unistd.h>
2466 #ifdef HAVE_GRP_H
2467 #include <grp.h>
2468 #endif
2469 ],
2470 void* p = setgroups,
2471 AC_DEFINE(HAVE_SETGROUPS, 1, Define if you have the 'setgroups' function.)
2472 AC_MSG_RESULT(yes),
2473 AC_MSG_RESULT(no)
2474 )
2476 # check for openpty and forkpty
2478 AC_CHECK_FUNCS(openpty,,
2479 AC_CHECK_LIB(util,openpty,
2480 [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lutil"],
2481 AC_CHECK_LIB(bsd,openpty, [AC_DEFINE(HAVE_OPENPTY) LIBS="$LIBS -lbsd"])
2482 )
2483 )
2484 AC_CHECK_FUNCS(forkpty,,
2485 AC_CHECK_LIB(util,forkpty,
2486 [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lutil"],
2487 AC_CHECK_LIB(bsd,forkpty, [AC_DEFINE(HAVE_FORKPTY) LIBS="$LIBS -lbsd"])
2488 )
2489 )
2491 # check for long file support functions
2492 AC_CHECK_FUNCS(fseek64 fseeko fstatvfs ftell64 ftello statvfs)
2494 AC_REPLACE_FUNCS(dup2 getcwd strdup strerror memmove)
2495 AC_CHECK_FUNCS(getpgrp,
2496 AC_TRY_COMPILE([#include <unistd.h>],
2497 [getpgrp(0);],
2498 AC_DEFINE(GETPGRP_HAVE_ARG, 1,
2499 [Define if getpgrp() must be called as getpgrp(0).])
2500 )
2501 )
2502 AC_CHECK_FUNCS(setpgrp,
2503 AC_TRY_COMPILE([#include <unistd.h>],
2504 [setpgrp(0,0);],
2505 AC_DEFINE(SETPGRP_HAVE_ARG, 1,
2506 [Define if setpgrp() must be called as setpgrp(0, 0).])
2507 )
2508 )
2509 AC_CHECK_FUNCS(gettimeofday,
2510 AC_TRY_COMPILE([#include <sys/time.h>],
2511 [gettimeofday((struct timeval*)0,(struct timezone*)0);], ,
2512 AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
2513 [Define if gettimeofday() does not have second (timezone) argument
2514 This is the case on Motorola V4 (R40V4.2)])
2515 )
2516 )
2518 AC_MSG_CHECKING(for major, minor, and makedev)
2519 AC_TRY_LINK([
2520 #if defined(MAJOR_IN_MKDEV)
2521 #include <sys/mkdev.h>
2522 #elif defined(MAJOR_IN_SYSMACROS)
2523 #include <sys/sysmacros.h>
2524 #else
2525 #include <sys/types.h>
2526 #endif
2527 ],[
2528 makedev(major(0),minor(0));
2529 ],[
2530 AC_DEFINE(HAVE_DEVICE_MACROS, 1,
2531 [Define to 1 if you have the device macros.])
2532 AC_MSG_RESULT(yes)
2533 ],[
2534 AC_MSG_RESULT(no)
2535 ])
2537 # On OSF/1 V5.1, getaddrinfo is available, but a define
2538 # for [no]getaddrinfo in netdb.h.
2539 AC_MSG_CHECKING(for getaddrinfo)
2540 AC_TRY_LINK([
2541 #include <sys/types.h>
2542 #include <sys/socket.h>
2543 #include <netdb.h>
2544 #include <stdio.h>
2545 ],[
2546 getaddrinfo(NULL, NULL, NULL, NULL);
2547 ], [
2548 AC_MSG_RESULT(yes)
2549 AC_MSG_CHECKING(getaddrinfo bug)
2550 AC_TRY_RUN([
2551 #include <sys/types.h>
2552 #include <netdb.h>
2553 #include <string.h>
2554 #include <sys/socket.h>
2555 #include <netinet/in.h>
2557 main()
2558 {
2559 int passive, gaierr, inet4 = 0, inet6 = 0;
2560 struct addrinfo hints, *ai, *aitop;
2561 char straddr[INET6_ADDRSTRLEN], strport[16];
2563 for (passive = 0; passive <= 1; passive++) {
2564 memset(&hints, 0, sizeof(hints));
2565 hints.ai_family = AF_UNSPEC;
2566 hints.ai_flags = passive ? AI_PASSIVE : 0;
2567 hints.ai_socktype = SOCK_STREAM;
2568 hints.ai_protocol = IPPROTO_TCP;
2569 if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) {
2570 (void)gai_strerror(gaierr);
2571 goto bad;
2572 }
2573 for (ai = aitop; ai; ai = ai->ai_next) {
2574 if (ai->ai_addr == NULL ||
2575 ai->ai_addrlen == 0 ||
2576 getnameinfo(ai->ai_addr, ai->ai_addrlen,
2577 straddr, sizeof(straddr), strport, sizeof(strport),
2578 NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
2579 goto bad;
2580 }
2581 switch (ai->ai_family) {
2582 case AF_INET:
2583 if (strcmp(strport, "54321") != 0) {
2584 goto bad;
2585 }
2586 if (passive) {
2587 if (strcmp(straddr, "0.0.0.0") != 0) {
2588 goto bad;
2589 }
2590 } else {
2591 if (strcmp(straddr, "127.0.0.1") != 0) {
2592 goto bad;
2593 }
2594 }
2595 inet4++;
2596 break;
2597 case AF_INET6:
2598 if (strcmp(strport, "54321") != 0) {
2599 goto bad;
2600 }
2601 if (passive) {
2602 if (strcmp(straddr, "::") != 0) {
2603 goto bad;
2604 }
2605 } else {
2606 if (strcmp(straddr, "::1") != 0) {
2607 goto bad;
2608 }
2609 }
2610 inet6++;
2611 break;
2612 case AF_UNSPEC:
2613 goto bad;
2614 break;
2615 default:
2616 /* another family support? */
2617 break;
2618 }
2619 }
2620 }
2622 if (!(inet4 == 0 || inet4 == 2))
2623 goto bad;
2624 if (!(inet6 == 0 || inet6 == 2))
2625 goto bad;
2627 if (aitop)
2628 freeaddrinfo(aitop);
2629 exit(0);
2631 bad:
2632 if (aitop)
2633 freeaddrinfo(aitop);
2634 exit(1);
2635 }
2636 ],
2637 AC_MSG_RESULT(good)
2638 buggygetaddrinfo=no,
2639 AC_MSG_RESULT(buggy)
2640 buggygetaddrinfo=yes,
2641 AC_MSG_RESULT(buggy)
2642 buggygetaddrinfo=yes)], [
2643 AC_MSG_RESULT(no)
2644 buggygetaddrinfo=yes
2645 ])
2647 if test "$buggygetaddrinfo" = "yes"; then
2648 if test "$ipv6" = "yes"; then
2649 echo 'Fatal: You must get working getaddrinfo() function.'
2650 echo ' or you can specify "--disable-ipv6"'.
2651 exit 1
2652 fi
2653 else
2654 AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
2655 fi
2656 AC_CHECK_FUNCS(getnameinfo)
2658 # checks for structures
2659 AC_HEADER_TIME
2660 AC_STRUCT_TM
2661 AC_STRUCT_TIMEZONE
2662 AC_CHECK_MEMBERS([struct stat.st_rdev])
2663 AC_CHECK_MEMBERS([struct stat.st_blksize])
2664 AC_CHECK_MEMBERS([struct stat.st_flags])
2665 AC_CHECK_MEMBERS([struct stat.st_gen])
2666 AC_CHECK_MEMBERS([struct stat.st_birthtime])
2667 AC_STRUCT_ST_BLOCKS
2669 AC_MSG_CHECKING(for time.h that defines altzone)
2670 AC_CACHE_VAL(ac_cv_header_time_altzone,
2671 [AC_TRY_COMPILE([#include <time.h>], [return altzone;],
2672 ac_cv_header_time_altzone=yes,
2673 ac_cv_header_time_altzone=no)])
2674 AC_MSG_RESULT($ac_cv_header_time_altzone)
2675 if test $ac_cv_header_time_altzone = yes; then
2676 AC_DEFINE(HAVE_ALTZONE, 1, [Define this if your time.h defines altzone.])
2677 fi
2679 was_it_defined=no
2680 AC_MSG_CHECKING(whether sys/select.h and sys/time.h may both be included)
2681 AC_TRY_COMPILE([
2682 #include <sys/types.h>
2683 #include <sys/select.h>
2684 #include <sys/time.h>
2685 ], [;], [
2686 AC_DEFINE(SYS_SELECT_WITH_SYS_TIME, 1,
2687 [Define if you can safely include both <sys/select.h> and <sys/time.h>
2688 (which you can't on SCO ODT 3.0).])
2689 was_it_defined=yes
2690 ])
2691 AC_MSG_RESULT($was_it_defined)
2693 AC_MSG_CHECKING(for addrinfo)
2694 AC_CACHE_VAL(ac_cv_struct_addrinfo,
2695 AC_TRY_COMPILE([
2696 # include <netdb.h>],
2697 [struct addrinfo a],
2698 ac_cv_struct_addrinfo=yes,
2699 ac_cv_struct_addrinfo=no))
2700 AC_MSG_RESULT($ac_cv_struct_addrinfo)
2701 if test $ac_cv_struct_addrinfo = yes; then
2702 AC_DEFINE(HAVE_ADDRINFO, 1, [struct addrinfo (netdb.h)])
2703 fi
2705 AC_MSG_CHECKING(for sockaddr_storage)
2706 AC_CACHE_VAL(ac_cv_struct_sockaddr_storage,
2707 AC_TRY_COMPILE([
2708 # include <sys/types.h>
2709 # include <sys/socket.h>],
2710 [struct sockaddr_storage s],
2711 ac_cv_struct_sockaddr_storage=yes,
2712 ac_cv_struct_sockaddr_storage=no))
2713 AC_MSG_RESULT($ac_cv_struct_sockaddr_storage)
2714 if test $ac_cv_struct_sockaddr_storage = yes; then
2715 AC_DEFINE(HAVE_SOCKADDR_STORAGE, 1, [struct sockaddr_storage (sys/socket.h)])
2716 fi
2718 # checks for compiler characteristics
2720 AC_C_CHAR_UNSIGNED
2721 AC_C_CONST
2723 works=no
2724 AC_MSG_CHECKING(for working volatile)
2725 AC_TRY_COMPILE([],[volatile int x; x = 0;], works=yes,
2726 AC_DEFINE(volatile, [], [Define to empty if the keyword does not work.])
2727 )
2728 AC_MSG_RESULT($works)
2730 works=no
2731 AC_MSG_CHECKING(for working signed char)
2732 AC_TRY_COMPILE([], [signed char c;], works=yes,
2733 AC_DEFINE(signed, [], [Define to empty if the keyword does not work.])
2734 )
2735 AC_MSG_RESULT($works)
2737 have_prototypes=no
2738 AC_MSG_CHECKING(for prototypes)
2739 AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],[
2740 AC_DEFINE(HAVE_PROTOTYPES, 1,
2741 [Define if your compiler supports function prototype])
2742 have_prototypes=yes
2743 ])
2744 AC_MSG_RESULT($have_prototypes)
2746 works=no
2747 AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
2748 AC_TRY_COMPILE([
2749 #include <stdarg.h>
2750 int foo(int x, ...) {
2751 va_list va;
2752 va_start(va, x);
2753 va_arg(va, int);
2754 va_arg(va, char *);
2755 va_arg(va, double);
2756 return 0;
2757 }
2758 ], [return foo(10, "", 3.14);], [
2759 AC_DEFINE(HAVE_STDARG_PROTOTYPES, 1,
2760 [Define if your compiler supports variable length function prototypes
2761 (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h>])
2762 works=yes
2763 ])
2764 AC_MSG_RESULT($works)
2766 # check for socketpair
2767 AC_MSG_CHECKING(for socketpair)
2768 AC_TRY_COMPILE([
2769 #include <sys/types.h>
2770 #include <sys/socket.h>
2771 ], void *x=socketpair,
2772 AC_DEFINE(HAVE_SOCKETPAIR, 1, Define if you have the 'socketpair' function.)
2773 AC_MSG_RESULT(yes),
2774 AC_MSG_RESULT(no)
2775 )
2777 # check if sockaddr has sa_len member
2778 AC_MSG_CHECKING(if sockaddr has sa_len member)
2779 AC_TRY_COMPILE([#include <sys/types.h>
2780 #include <sys/socket.h>],
2781 [struct sockaddr x;
2782 x.sa_len = 0;],
2783 AC_MSG_RESULT(yes)
2784 AC_DEFINE(HAVE_SOCKADDR_SA_LEN, 1, [Define if sockaddr has sa_len member]),
2785 AC_MSG_RESULT(no))
2787 va_list_is_array=no
2788 AC_MSG_CHECKING(whether va_list is an array)
2789 AC_TRY_COMPILE([
2790 #ifdef HAVE_STDARG_PROTOTYPES
2791 #include <stdarg.h>
2792 #else
2793 #include <varargs.h>
2794 #endif
2795 ], [va_list list1, list2; list1 = list2;], , [
2796 AC_DEFINE(VA_LIST_IS_ARRAY, 1, [Define if a va_list is an array of some kind])
2797 va_list_is_array=yes
2798 ])
2799 AC_MSG_RESULT($va_list_is_array)
2801 # sigh -- gethostbyname_r is a mess; it can have 3, 5 or 6 arguments :-(
2802 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
2803 [Define this if you have some version of gethostbyname_r()])
2805 AC_CHECK_FUNC(gethostbyname_r, [
2806 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2807 AC_MSG_CHECKING([gethostbyname_r with 6 args])
2808 OLD_CFLAGS=$CFLAGS
2809 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
2810 AC_TRY_COMPILE([
2811 # include <netdb.h>
2812 ], [
2813 char *name;
2814 struct hostent *he, *res;
2815 char buffer[2048];
2816 int buflen = 2048;
2817 int h_errnop;
2819 (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop)
2820 ], [
2821 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2822 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
2823 [Define this if you have the 6-arg version of gethostbyname_r().])
2824 AC_MSG_RESULT(yes)
2825 ], [
2826 AC_MSG_RESULT(no)
2827 AC_MSG_CHECKING([gethostbyname_r with 5 args])
2828 AC_TRY_COMPILE([
2829 # include <netdb.h>
2830 ], [
2831 char *name;
2832 struct hostent *he;
2833 char buffer[2048];
2834 int buflen = 2048;
2835 int h_errnop;
2837 (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop)
2838 ], [
2839 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2840 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
2841 [Define this if you have the 5-arg version of gethostbyname_r().])
2842 AC_MSG_RESULT(yes)
2843 ], [
2844 AC_MSG_RESULT(no)
2845 AC_MSG_CHECKING([gethostbyname_r with 3 args])
2846 AC_TRY_COMPILE([
2847 # include <netdb.h>
2848 ], [
2849 char *name;
2850 struct hostent *he;
2851 struct hostent_data data;
2853 (void) gethostbyname_r(name, he, &data);
2854 ], [
2855 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
2856 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
2857 [Define this if you have the 3-arg version of gethostbyname_r().])
2858 AC_MSG_RESULT(yes)
2859 ], [
2860 AC_MSG_RESULT(no)
2861 ])
2862 ])
2863 ])
2864 CFLAGS=$OLD_CFLAGS
2865 ], [
2866 AC_CHECK_FUNCS(gethostbyname)
2867 ])
2868 AC_SUBST(HAVE_GETHOSTBYNAME_R_6_ARG)
2869 AC_SUBST(HAVE_GETHOSTBYNAME_R_5_ARG)
2870 AC_SUBST(HAVE_GETHOSTBYNAME_R_3_ARG)
2871 AC_SUBST(HAVE_GETHOSTBYNAME_R)
2872 AC_SUBST(HAVE_GETHOSTBYNAME)
2874 # checks for system services
2875 # (none yet)
2877 # Linux requires this for correct f.p. operations
2878 AC_CHECK_FUNC(__fpu_control,
2879 [],
2880 [AC_CHECK_LIB(ieee, __fpu_control)
2881 ])
2883 # Check for --with-fpectl
2884 AC_MSG_CHECKING(for --with-fpectl)
2885 AC_ARG_WITH(fpectl,
2886 AC_HELP_STRING(--with-fpectl, enable SIGFPE catching),
2887 [
2888 if test "$withval" != no
2889 then
2890 AC_DEFINE(WANT_SIGFPE_HANDLER, 1,
2891 [Define if you want SIGFPE handled (see Include/pyfpe.h).])
2892 AC_MSG_RESULT(yes)
2893 else AC_MSG_RESULT(no)
2894 fi],
2895 [AC_MSG_RESULT(no)])
2897 # check for --with-libm=...
2898 AC_SUBST(LIBM)
2899 case $ac_sys_system in
2900 Darwin) ;;
2901 BeOS) ;;
2902 *) LIBM=-lm
2903 esac
2904 AC_MSG_CHECKING(for --with-libm=STRING)
2905 AC_ARG_WITH(libm,
2906 AC_HELP_STRING(--with-libm=STRING, math library),
2907 [
2908 if test "$withval" = no
2909 then LIBM=
2910 AC_MSG_RESULT(force LIBM empty)
2911 elif test "$withval" != yes
2912 then LIBM=$withval
2913 AC_MSG_RESULT(set LIBM="$withval")
2914 else AC_MSG_ERROR([proper usage is --with-libm=STRING])
2915 fi],
2916 [AC_MSG_RESULT(default LIBM="$LIBM")])
2918 # check for --with-libc=...
2919 AC_SUBST(LIBC)
2920 AC_MSG_CHECKING(for --with-libc=STRING)
2921 AC_ARG_WITH(libc,
2922 AC_HELP_STRING(--with-libc=STRING, C library),
2923 [
2924 if test "$withval" = no
2925 then LIBC=
2926 AC_MSG_RESULT(force LIBC empty)
2927 elif test "$withval" != yes
2928 then LIBC=$withval
2929 AC_MSG_RESULT(set LIBC="$withval")
2930 else AC_MSG_ERROR([proper usage is --with-libc=STRING])
2931 fi],
2932 [AC_MSG_RESULT(default LIBC="$LIBC")])
2934 # check for hypot() in math library
2935 LIBS_SAVE=$LIBS
2936 LIBS="$LIBS $LIBM"
2937 AC_REPLACE_FUNCS(hypot)
2938 LIBS=$LIBS_SAVE
2940 # check for wchar.h
2941 AC_CHECK_HEADER(wchar.h, [
2942 AC_DEFINE(HAVE_WCHAR_H, 1,
2943 [Define if the compiler provides a wchar.h header file.])
2944 wchar_h="yes"
2945 ],
2946 wchar_h="no"
2947 )
2949 # determine wchar_t size
2950 if test "$wchar_h" = yes
2951 then
2952 AC_CHECK_SIZEOF(wchar_t, 4, [#include <wchar.h>])
2953 fi
2955 AC_MSG_CHECKING(for UCS-4 tcl)
2956 have_ucs4_tcl=no
2957 AC_TRY_COMPILE([
2958 #include <tcl.h>
2959 #if TCL_UTF_MAX != 6
2960 # error "NOT UCS4_TCL"
2961 #endif], [], [
2962 AC_DEFINE(HAVE_UCS4_TCL, 1, [Define this if you have tcl and TCL_UTF_MAX==6])
2963 have_ucs4_tcl=yes
2964 ])
2965 AC_MSG_RESULT($have_ucs4_tcl)
2967 # check whether wchar_t is signed or not
2968 if test "$wchar_h" = yes
2969 then
2970 # check whether wchar_t is signed or not
2971 AC_MSG_CHECKING(whether wchar_t is signed)
2972 AC_CACHE_VAL(ac_cv_wchar_t_signed, [
2973 AC_TRY_RUN([
2974 #include <wchar.h>
2975 int main()
2976 {
2977 /* Success: exit code 0 */
2978 exit((((wchar_t) -1) < ((wchar_t) 0)) ? 0 : 1);
2979 }
2980 ],
2981 ac_cv_wchar_t_signed=yes,
2982 ac_cv_wchar_t_signed=no,
2983 ac_cv_wchar_t_signed=yes)])
2984 AC_MSG_RESULT($ac_cv_wchar_t_signed)
2985 fi
2987 AC_MSG_CHECKING(what type to use for unicode)
2988 dnl quadrigraphs "@<:@" and "@:>@" produce "[" and "]" in the output
2989 AC_ARG_ENABLE(unicode,
2990 AC_HELP_STRING(--enable-unicode@<:@=ucs@<:@24@:>@@:>@, Enable Unicode strings (default is yes)),
2991 [],
2992 [enable_unicode=yes])
2994 if test $enable_unicode = yes
2995 then
2996 # Without any arguments, Py_UNICODE defaults to two-byte mode
2997 case "$have_ucs4_tcl" in
2998 yes) enable_unicode="ucs4"
2999 ;;
3000 *) enable_unicode="ucs2"
3001 ;;
3002 esac
3003 fi
3005 AH_TEMPLATE(Py_UNICODE_SIZE,
3006 [Define as the size of the unicode type.])
3007 case "$enable_unicode" in
3008 ucs2) unicode_size="2"
3009 AC_DEFINE(Py_UNICODE_SIZE,2)
3010 ;;
3011 ucs4) unicode_size="4"
3012 AC_DEFINE(Py_UNICODE_SIZE,4)
3013 ;;
3014 esac
3016 AH_TEMPLATE(PY_UNICODE_TYPE,
3017 [Define as the integral type used for Unicode representation.])
3019 AC_SUBST(UNICODE_OBJS)
3020 if test "$enable_unicode" = "no"
3021 then
3022 UNICODE_OBJS=""
3023 AC_MSG_RESULT(not used)
3024 else
3025 UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o"
3026 AC_DEFINE(Py_USING_UNICODE, 1,
3027 [Define if you want to have a Unicode type.])
3029 # wchar_t is only usable if it maps to an unsigned type
3030 if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" \
3031 -a "$ac_cv_wchar_t_signed" = "no"
3032 then
3033 PY_UNICODE_TYPE="wchar_t"
3034 AC_DEFINE(HAVE_USABLE_WCHAR_T, 1,
3035 [Define if you have a useable wchar_t type defined in wchar.h; useable
3036 means wchar_t must be an unsigned type with at least 16 bits. (see
3037 Include/unicodeobject.h).])
3038 AC_DEFINE(PY_UNICODE_TYPE,wchar_t)
3039 elif test "$ac_cv_sizeof_short" = "$unicode_size"
3040 then
3041 PY_UNICODE_TYPE="unsigned short"
3042 AC_DEFINE(PY_UNICODE_TYPE,unsigned short)
3043 elif test "$ac_cv_sizeof_long" = "$unicode_size"
3044 then
3045 PY_UNICODE_TYPE="unsigned long"
3046 AC_DEFINE(PY_UNICODE_TYPE,unsigned long)
3047 else
3048 PY_UNICODE_TYPE="no type found"
3049 fi
3050 AC_MSG_RESULT($PY_UNICODE_TYPE)
3051 fi
3053 # check for endianness
3054 AC_C_BIGENDIAN
3055 AH_VERBATIM([WORDS_BIGENDIAN],
3056 [
3057 /* Define to 1 if your processor stores words with the most significant byte
3058 first (like Motorola and SPARC, unlike Intel and VAX).
3060 The block below does compile-time checking for endianness on platforms
3061 that use GCC and therefore allows compiling fat binaries on OSX by using
3062 '-arch ppc -arch i386' as the compile flags. The phrasing was choosen
3063 such that the configure-result is used on systems that don't use GCC.
3064 */
3065 #ifdef __BIG_ENDIAN__
3066 #define WORDS_BIGENDIAN 1
3067 #else
3068 #ifndef __LITTLE_ENDIAN__
3069 #undef WORDS_BIGENDIAN
3070 #endif
3071 #endif])
3073 # Check whether right shifting a negative integer extends the sign bit
3074 # or fills with zeros (like the Cray J90, according to Tim Peters).
3075 AC_MSG_CHECKING(whether right shift extends the sign bit)
3076 AC_CACHE_VAL(ac_cv_rshift_extends_sign, [
3077 AC_TRY_RUN([
3078 int main()
3079 {
3080 exit(((-1)>>3 == -1) ? 0 : 1);
3081 }
3082 ],
3083 ac_cv_rshift_extends_sign=yes,
3084 ac_cv_rshift_extends_sign=no,
3085 ac_cv_rshift_extends_sign=yes)])
3086 AC_MSG_RESULT($ac_cv_rshift_extends_sign)
3087 if test "$ac_cv_rshift_extends_sign" = no
3088 then
3089 AC_DEFINE(SIGNED_RIGHT_SHIFT_ZERO_FILLS, 1,
3090 [Define if i>>j for signed int i does not extend the sign bit
3091 when i < 0])
3092 fi
3094 # check for getc_unlocked and related locking functions
3095 AC_MSG_CHECKING(for getc_unlocked() and friends)
3096 AC_CACHE_VAL(ac_cv_have_getc_unlocked, [
3097 AC_TRY_LINK([#include <stdio.h>],[
3098 FILE *f = fopen("/dev/null", "r");
3099 flockfile(f);
3100 getc_unlocked(f);
3101 funlockfile(f);
3102 ], ac_cv_have_getc_unlocked=yes, ac_cv_have_getc_unlocked=no)])
3103 AC_MSG_RESULT($ac_cv_have_getc_unlocked)
3104 if test "$ac_cv_have_getc_unlocked" = yes
3105 then
3106 AC_DEFINE(HAVE_GETC_UNLOCKED, 1,
3107 [Define this if you have flockfile(), getc_unlocked(), and funlockfile()])
3108 fi
3110 # check where readline lives
3111 # save the value of LIBS so we don't actually link Python with readline
3112 LIBS_no_readline=$LIBS
3113 AC_CHECK_LIB(readline, readline)
3114 if test "$ac_cv_have_readline_readline" = no
3115 then
3116 AC_CHECK_LIB(termcap, readline)
3117 fi
3119 # check for readline 2.1
3120 AC_CHECK_LIB(readline, rl_callback_handler_install,
3121 AC_DEFINE(HAVE_RL_CALLBACK, 1,
3122 [Define if you have readline 2.1]), , )
3124 # check for readline 2.2
3125 AC_TRY_CPP([#include <readline/readline.h>],
3126 have_readline=yes, have_readline=no)
3127 if test $have_readline = yes
3128 then
3129 AC_EGREP_HEADER([extern int rl_completion_append_character;],
3130 [readline/readline.h],
3131 AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER, 1,
3132 [Define if you have readline 2.2]), )
3133 fi
3135 # check for readline 4.0
3136 AC_CHECK_LIB(readline, rl_pre_input_hook,
3137 AC_DEFINE(HAVE_RL_PRE_INPUT_HOOK, 1,
3138 [Define if you have readline 4.0]), , )
3140 # also in 4.0
3141 AC_CHECK_LIB(readline, rl_completion_display_matches_hook,
3142 AC_DEFINE(HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK, 1,
3143 [Define if you have readline 4.0]), , )
3145 # check for readline 4.2
3146 AC_CHECK_LIB(readline, rl_completion_matches,
3147 AC_DEFINE(HAVE_RL_COMPLETION_MATCHES, 1,
3148 [Define if you have readline 4.2]), , )
3150 # also in readline 4.2
3151 AC_TRY_CPP([#include <readline/readline.h>],
3152 have_readline=yes, have_readline=no)
3153 if test $have_readline = yes
3154 then
3155 AC_EGREP_HEADER([extern int rl_catch_signals;],
3156 [readline/readline.h],
3157 AC_DEFINE(HAVE_RL_CATCH_SIGNAL, 1,
3158 [Define if you can turn off readline's signal handling.]), )
3159 fi
3161 # End of readline checks: restore LIBS
3162 LIBS=$LIBS_no_readline
3164 AC_MSG_CHECKING(for broken nice())
3165 AC_CACHE_VAL(ac_cv_broken_nice, [
3166 AC_TRY_RUN([
3167 int main()
3168 {
3169 int val1 = nice(1);
3170 if (val1 != -1 && val1 == nice(2))
3171 exit(0);
3172 exit(1);
3173 }
3174 ],
3175 ac_cv_broken_nice=yes,
3176 ac_cv_broken_nice=no,
3177 ac_cv_broken_nice=no)])
3178 AC_MSG_RESULT($ac_cv_broken_nice)
3179 if test "$ac_cv_broken_nice" = yes
3180 then
3181 AC_DEFINE(HAVE_BROKEN_NICE, 1,
3182 [Define if nice() returns success/failure instead of the new priority.])
3183 fi
3185 AC_MSG_CHECKING(for broken poll())
3186 AC_TRY_RUN([
3187 #include <poll.h>
3189 int main (void)
3190 {
3191 struct pollfd poll_struct = { 42, POLLIN|POLLPRI|POLLOUT, 0 };
3193 close (42);
3195 int poll_test = poll (&poll_struct, 1, 0);
3197 if (poll_test < 0)
3198 {
3199 exit(0);
3200 }
3201 else if (poll_test == 0 && poll_struct.revents != POLLNVAL)
3202 {
3203 exit(0);
3204 }
3205 else
3206 {
3207 exit(1);
3208 }
3209 }
3210 ],
3211 ac_cv_broken_poll=yes,
3212 ac_cv_broken_poll=no,
3213 ac_cv_broken_poll=no)
3214 AC_MSG_RESULT($ac_cv_broken_poll)
3215 if test "$ac_cv_broken_poll" = yes
3216 then
3217 AC_DEFINE(HAVE_BROKEN_POLL, 1,
3218 [Define if poll() sets errno on invalid file descriptors.])
3219 fi
3221 # Before we can test tzset, we need to check if struct tm has a tm_zone
3222 # (which is not required by ISO C or UNIX spec) and/or if we support
3223 # tzname[]
3224 AC_STRUCT_TIMEZONE
3226 # check tzset(3) exists and works like we expect it to
3227 AC_MSG_CHECKING(for working tzset())
3228 AC_CACHE_VAL(ac_cv_working_tzset, [
3229 AC_TRY_RUN([
3230 #include <stdlib.h>
3231 #include <time.h>
3232 #include <string.h>
3234 #if HAVE_TZNAME
3235 extern char *tzname[];
3236 #endif
3238 int main()
3239 {
3240 /* Note that we need to ensure that not only does tzset(3)
3241 do 'something' with localtime, but it works as documented
3242 in the library reference and as expected by the test suite.
3243 This includes making sure that tzname is set properly if
3244 tm->tm_zone does not exist since it is the alternative way
3245 of getting timezone info.
3247 Red Hat 6.2 doesn't understand the southern hemisphere
3248 after New Year's Day.
3249 */
3251 time_t groundhogday = 1044144000; /* GMT-based */
3252 time_t midyear = groundhogday + (365 * 24 * 3600 / 2);
3254 putenv("TZ=UTC+0");
3255 tzset();
3256 if (localtime(&groundhogday)->tm_hour != 0)
3257 exit(1);
3258 #if HAVE_TZNAME
3259 /* For UTC, tzname[1] is sometimes "", sometimes " " */
3260 if (strcmp(tzname[0], "UTC") ||
3261 (tzname[1][0] != 0 && tzname[1][0] != ' '))
3262 exit(1);
3263 #endif
3265 putenv("TZ=EST+5EDT,M4.1.0,M10.5.0");
3266 tzset();
3267 if (localtime(&groundhogday)->tm_hour != 19)
3268 exit(1);
3269 #if HAVE_TZNAME
3270 if (strcmp(tzname[0], "EST") || strcmp(tzname[1], "EDT"))
3271 exit(1);
3272 #endif
3274 putenv("TZ=AEST-10AEDT-11,M10.5.0,M3.5.0");
3275 tzset();
3276 if (localtime(&groundhogday)->tm_hour != 11)
3277 exit(1);
3278 #if HAVE_TZNAME
3279 if (strcmp(tzname[0], "AEST") || strcmp(tzname[1], "AEDT"))
3280 exit(1);
3281 #endif
3283 #if HAVE_STRUCT_TM_TM_ZONE
3284 if (strcmp(localtime(&groundhogday)->tm_zone, "AEDT"))
3285 exit(1);
3286 if (strcmp(localtime(&midyear)->tm_zone, "AEST"))
3287 exit(1);
3288 #endif
3290 exit(0);
3291 }
3292 ],
3293 ac_cv_working_tzset=yes,
3294 ac_cv_working_tzset=no,
3295 ac_cv_working_tzset=no)])
3296 AC_MSG_RESULT($ac_cv_working_tzset)
3297 if test "$ac_cv_working_tzset" = yes
3298 then
3299 AC_DEFINE(HAVE_WORKING_TZSET, 1,
3300 [Define if tzset() actually switches the local timezone in a meaningful way.])
3301 fi
3303 # Look for subsecond timestamps in struct stat
3304 AC_MSG_CHECKING(for tv_nsec in struct stat)
3305 AC_CACHE_VAL(ac_cv_stat_tv_nsec,
3306 AC_TRY_COMPILE([#include <sys/stat.h>], [
3307 struct stat st;
3308 st.st_mtim.tv_nsec = 1;
3309 ],
3310 ac_cv_stat_tv_nsec=yes,
3311 ac_cv_stat_tv_nsec=no,
3312 ac_cv_stat_tv_nsec=no))
3313 AC_MSG_RESULT($ac_cv_stat_tv_nsec)
3314 if test "$ac_cv_stat_tv_nsec" = yes
3315 then
3316 AC_DEFINE(HAVE_STAT_TV_NSEC, 1,
3317 [Define if you have struct stat.st_mtim.tv_nsec])
3318 fi
3320 # Look for BSD style subsecond timestamps in struct stat
3321 AC_MSG_CHECKING(for tv_nsec2 in struct stat)
3322 AC_CACHE_VAL(ac_cv_stat_tv_nsec2,
3323 AC_TRY_COMPILE([#include <sys/stat.h>], [
3324 struct stat st;
3325 st.st_mtimespec.tv_nsec = 1;
3326 ],
3327 ac_cv_stat_tv_nsec2=yes,
3328 ac_cv_stat_tv_nsec2=no,
3329 ac_cv_stat_tv_nsec2=no))
3330 AC_MSG_RESULT($ac_cv_stat_tv_nsec2)
3331 if test "$ac_cv_stat_tv_nsec2" = yes
3332 then
3333 AC_DEFINE(HAVE_STAT_TV_NSEC2, 1,
3334 [Define if you have struct stat.st_mtimensec])
3335 fi
3337 # On HP/UX 11.0, mvwdelch is a block with a return statement
3338 AC_MSG_CHECKING(whether mvwdelch is an expression)
3339 AC_CACHE_VAL(ac_cv_mvwdelch_is_expression,
3340 AC_TRY_COMPILE([#include <curses.h>], [
3341 int rtn;
3342 rtn = mvwdelch(0,0,0);
3343 ], ac_cv_mvwdelch_is_expression=yes,
3344 ac_cv_mvwdelch_is_expression=no,
3345 ac_cv_mvwdelch_is_expression=yes))
3346 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
3348 if test "$ac_cv_mvwdelch_is_expression" = yes
3349 then
3350 AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
3351 [Define if mvwdelch in curses.h is an expression.])
3352 fi
3354 AC_MSG_CHECKING(whether WINDOW has _flags)
3355 AC_CACHE_VAL(ac_cv_window_has_flags,
3356 AC_TRY_COMPILE([#include <curses.h>], [
3357 WINDOW *w;
3358 w->_flags = 0;
3359 ], ac_cv_window_has_flags=yes,
3360 ac_cv_window_has_flags=no,
3361 ac_cv_window_has_flags=no))
3362 AC_MSG_RESULT($ac_cv_window_has_flags)
3365 if test "$ac_cv_window_has_flags" = yes
3366 then
3367 AC_DEFINE(WINDOW_HAS_FLAGS, 1,
3368 [Define if WINDOW in curses.h offers a field _flags.])
3369 fi
3371 AC_MSG_CHECKING(for is_term_resized)
3372 AC_TRY_COMPILE([#include <curses.h>], void *x=is_term_resized,
3373 AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
3374 AC_MSG_RESULT(yes),
3375 AC_MSG_RESULT(no)
3376 )
3378 AC_MSG_CHECKING(for resize_term)
3379 AC_TRY_COMPILE([#include <curses.h>], void *x=resize_term,
3380 AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
3381 AC_MSG_RESULT(yes),
3382 AC_MSG_RESULT(no)
3383 )
3385 AC_MSG_CHECKING(for resizeterm)
3386 AC_TRY_COMPILE([#include <curses.h>], void *x=resizeterm,
3387 AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
3388 AC_MSG_RESULT(yes),
3389 AC_MSG_RESULT(no)
3390 )
3392 AC_MSG_CHECKING(for /dev/ptmx)
3394 if test -r /dev/ptmx
3395 then
3396 AC_MSG_RESULT(yes)
3397 AC_DEFINE(HAVE_DEV_PTMX, 1,
3398 [Define if we have /dev/ptmx.])
3399 else
3400 AC_MSG_RESULT(no)
3401 fi
3403 AC_MSG_CHECKING(for /dev/ptc)
3405 if test -r /dev/ptc
3406 then
3407 AC_MSG_RESULT(yes)
3408 AC_DEFINE(HAVE_DEV_PTC, 1,
3409 [Define if we have /dev/ptc.])
3410 else
3411 AC_MSG_RESULT(no)
3412 fi
3414 AC_MSG_CHECKING(for %zd printf() format support)
3415 AC_TRY_RUN([#include <stdio.h>
3416 #include <stddef.h>
3417 #include <string.h>
3419 int main()
3420 {
3421 char buffer[256];
3423 #ifdef HAVE_SSIZE_T
3424 typedef ssize_t Py_ssize_t;
3425 #elif SIZEOF_VOID_P == SIZEOF_LONG
3426 typedef long Py_ssize_t;
3427 #else
3428 typedef int Py_ssize_t;
3429 #endif
3431 if(sprintf(buffer, "%zd", (size_t)123) < 0)
3432 return 1;
3434 if (strcmp(buffer, "123"))
3435 return 1;
3437 if (sprintf(buffer, "%zd", (Py_ssize_t)-123) < 0)
3438 return 1;
3440 if (strcmp(buffer, "-123"))
3441 return 1;
3443 return 0;
3444 }],
3445 [AC_MSG_RESULT(yes)
3446 AC_DEFINE(PY_FORMAT_SIZE_T, "z", [Define to printf format modifier for Py_ssize_t])],
3447 AC_MSG_RESULT(no))
3449 AC_CHECK_TYPE(socklen_t,,
3450 AC_DEFINE(socklen_t,int,
3451 Define to `int' if <sys/socket.h> does not define.),[
3452 #ifdef HAVE_SYS_TYPES_H
3453 #include <sys/types.h>
3454 #endif
3455 #ifdef HAVE_SYS_SOCKET_H
3456 #include <sys/socket.h>
3457 #endif
3458 ])
3460 AC_SUBST(THREADHEADERS)
3462 for h in `(cd $srcdir;echo Python/thread_*.h)`
3463 do
3464 THREADHEADERS="$THREADHEADERS \$(srcdir)/$h"
3465 done
3467 AC_SUBST(SRCDIRS)
3468 SRCDIRS="Parser Grammar Objects Python Modules Mac"
3469 AC_MSG_CHECKING(for build directories)
3470 for dir in $SRCDIRS; do
3471 if test ! -d $dir; then
3472 mkdir $dir
3473 fi
3474 done
3475 AC_MSG_RESULT(done)
3477 # generate output files
3478 AC_CONFIG_FILES(Makefile.pre Modules/Setup.config)
3479 AC_OUTPUT
3481 echo "creating Modules/Setup"
3482 if test ! -f Modules/Setup
3483 then
3484 cp $srcdir/Modules/Setup.dist Modules/Setup
3485 fi
3487 echo "creating Modules/Setup.local"
3488 if test ! -f Modules/Setup.local
3489 then
3490 echo "# Edit this file for local setup changes" >Modules/Setup.local
3491 fi
3493 echo "creating Makefile"
3494 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
3495 -s Modules Modules/Setup.config \
3496 Modules/Setup.local Modules/Setup
3498 case $ac_sys_system in
3499 BeOS)
3500 AC_MSG_WARN([
3502 Support for BeOS is deprecated as of Python 2.6.
3503 See PEP 11 for the gory details.
3504 ])
3505 ;;
3506 *) ;;
3507 esac
3509 mv config.c Modules