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