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