Mercurial > hg > CbC > CbC_gcc
comparison config/acx.m4 @ 0:a06113de4d67
first commit
author | kent <kent@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 17 Jul 2009 14:47:48 +0900 |
parents | |
children | 77e2b8dfacca |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a06113de4d67 |
---|---|
1 # Autoconf M4 include file defining utility macros for complex Canadian | |
2 # cross builds. | |
3 | |
4 dnl #### | |
5 dnl # _GCC_TOPLEV_NONCANONICAL_BUILD | |
6 dnl # $build_alias or canonical $build if blank. | |
7 dnl # Used when we would use $build_alias, but empty is not OK. | |
8 AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_BUILD], | |
9 [AC_REQUIRE([AC_CANONICAL_BUILD]) []dnl | |
10 case ${build_alias} in | |
11 "") build_noncanonical=${build} ;; | |
12 *) build_noncanonical=${build_alias} ;; | |
13 esac | |
14 ]) []dnl # _GCC_TOPLEV_NONCANONICAL_BUILD | |
15 | |
16 dnl #### | |
17 dnl # _GCC_TOPLEV_NONCANONICAL_HOST | |
18 dnl # $host_alias, or $build_noncanonical if blank. | |
19 dnl # Used when we would use $host_alias, but empty is not OK. | |
20 AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_HOST], | |
21 [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl | |
22 case ${host_alias} in | |
23 "") host_noncanonical=${build_noncanonical} ;; | |
24 *) host_noncanonical=${host_alias} ;; | |
25 esac | |
26 ]) []dnl # _GCC_TOPLEV_NONCANONICAL_HOST | |
27 | |
28 dnl #### | |
29 dnl # _GCC_TOPLEV_NONCANONICAL_TARGET | |
30 dnl # $target_alias or $host_noncanonical if blank. | |
31 dnl # Used when we would use $target_alias, but empty is not OK. | |
32 AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_TARGET], | |
33 [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_HOST]) []dnl | |
34 case ${target_alias} in | |
35 "") target_noncanonical=${host_noncanonical} ;; | |
36 *) target_noncanonical=${target_alias} ;; | |
37 esac | |
38 ]) []dnl # _GCC_TOPLEV_NONCANONICAL_TARGET | |
39 | |
40 dnl #### | |
41 dnl # ACX_NONCANONICAL_BUILD | |
42 dnl # Like underscored version, but AC_SUBST's. | |
43 AC_DEFUN([ACX_NONCANONICAL_BUILD], | |
44 [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl | |
45 AC_SUBST(build_noncanonical) | |
46 ]) []dnl # ACX_NONCANONICAL_BUILD | |
47 | |
48 dnl #### | |
49 dnl # ACX_NONCANONICAL_HOST | |
50 dnl # Like underscored version, but AC_SUBST's. | |
51 AC_DEFUN([ACX_NONCANONICAL_HOST], | |
52 [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_HOST]) []dnl | |
53 AC_SUBST(host_noncanonical) | |
54 ]) []dnl # ACX_NONCANONICAL_HOST | |
55 | |
56 dnl #### | |
57 dnl # ACX_NONCANONICAL_TARGET | |
58 dnl # Like underscored version, but AC_SUBST's. | |
59 AC_DEFUN([ACX_NONCANONICAL_TARGET], | |
60 [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_TARGET]) []dnl | |
61 AC_SUBST(target_noncanonical) | |
62 ]) []dnl # ACX_NONCANONICAL_TARGET | |
63 | |
64 dnl #### | |
65 dnl # GCC_TOPLEV_SUBDIRS | |
66 dnl # GCC & friends build 'build', 'host', and 'target' tools. These must | |
67 dnl # be separated into three well-known subdirectories of the build directory: | |
68 dnl # build_subdir, host_subdir, and target_subdir. The values are determined | |
69 dnl # here so that they can (theoretically) be changed in the future. They | |
70 dnl # were previously reproduced across many different files. | |
71 dnl # | |
72 dnl # This logic really amounts to very little with autoconf 2.13; it will | |
73 dnl # amount to a lot more with autoconf 2.5x. | |
74 AC_DEFUN([GCC_TOPLEV_SUBDIRS], | |
75 [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_TARGET]) []dnl | |
76 AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl | |
77 | |
78 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to | |
79 # have matching libraries, they should use host libraries: Makefile.tpl | |
80 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR). | |
81 # However, they still use the build modules, because the corresponding | |
82 # host modules (e.g. bison) are only built for the host when bootstrap | |
83 # finishes. So: | |
84 # - build_subdir is where we find build modules, and never changes. | |
85 # - build_libsubdir is where we find build libraries, and can be overridden. | |
86 | |
87 # Prefix 'build-' so this never conflicts with target_subdir. | |
88 build_subdir="build-${build_noncanonical}" | |
89 AC_ARG_WITH(build-libsubdir, | |
90 [ --with-build-libsubdir=[DIR] Directory where to find libraries for build system], | |
91 build_libsubdir="$withval", | |
92 build_libsubdir="$build_subdir") | |
93 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories | |
94 if ( test $srcdir = . && test -d gcc ) \ | |
95 || test -d $srcdir/../host-${host_noncanonical}; then | |
96 host_subdir="host-${host_noncanonical}" | |
97 else | |
98 host_subdir=. | |
99 fi | |
100 # No prefix. | |
101 target_subdir=${target_noncanonical} | |
102 AC_SUBST([build_libsubdir]) []dnl | |
103 AC_SUBST([build_subdir]) []dnl | |
104 AC_SUBST([host_subdir]) []dnl | |
105 AC_SUBST([target_subdir]) []dnl | |
106 ]) []dnl # GCC_TOPLEV_SUBDIRS | |
107 | |
108 | |
109 #### | |
110 # _NCN_TOOL_PREFIXES: Some stuff that oughtta be done in AC_CANONICAL_SYSTEM | |
111 # or AC_INIT. | |
112 # These demand that AC_CANONICAL_SYSTEM be called beforehand. | |
113 AC_DEFUN([_NCN_TOOL_PREFIXES], | |
114 [ncn_tool_prefix= | |
115 test -n "$host_alias" && ncn_tool_prefix=$host_alias- | |
116 ncn_target_tool_prefix= | |
117 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias- | |
118 ]) []dnl # _NCN_TOOL_PREFIXES | |
119 | |
120 #### | |
121 # NCN_STRICT_CHECK_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path]) | |
122 # Like plain AC_CHECK_TOOLS, but require prefix if build!=host. | |
123 | |
124 AC_DEFUN([NCN_STRICT_CHECK_TOOLS], | |
125 [AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl | |
126 AC_ARG_VAR([$1], [$1 for the host]) | |
127 | |
128 if test -n "[$]$1"; then | |
129 ac_cv_prog_$1=[$]$1 | |
130 elif test -n "$ac_cv_prog_$1"; then | |
131 $1=$ac_cv_prog_$1 | |
132 fi | |
133 | |
134 if test -n "$ac_cv_prog_$1"; then | |
135 for ncn_progname in $2; do | |
136 AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) | |
137 done | |
138 fi | |
139 | |
140 for ncn_progname in $2; do | |
141 if test -n "$ncn_tool_prefix"; then | |
142 AC_CHECK_PROG([$1], [${ncn_tool_prefix}${ncn_progname}], | |
143 [${ncn_tool_prefix}${ncn_progname}], , [$4]) | |
144 fi | |
145 if test -z "$ac_cv_prog_$1" && test $build = $host ; then | |
146 AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) | |
147 fi | |
148 test -n "$ac_cv_prog_$1" && break | |
149 done | |
150 | |
151 if test -z "$ac_cv_prog_$1" ; then | |
152 ifelse([$3],[], [set dummy $2 | |
153 if test $build = $host ; then | |
154 $1="[$]2" | |
155 else | |
156 $1="${ncn_tool_prefix}[$]2" | |
157 fi], [$1="$3"]) | |
158 fi | |
159 ]) []dnl # NCN_STRICT_CHECK_TOOLS | |
160 | |
161 #### | |
162 # NCN_STRICT_CHECK_TARGET_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path]) | |
163 # Like CVS Autoconf AC_CHECK_TARGET_TOOLS, but require prefix if build!=target. | |
164 | |
165 AC_DEFUN([NCN_STRICT_CHECK_TARGET_TOOLS], | |
166 [AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl | |
167 AC_ARG_VAR([$1], patsubst([$1], [_FOR_TARGET$], [])[ for the target]) | |
168 | |
169 if test -n "[$]$1"; then | |
170 ac_cv_prog_$1=[$]$1 | |
171 elif test -n "$ac_cv_prog_$1"; then | |
172 $1=$ac_cv_prog_$1 | |
173 fi | |
174 | |
175 if test -n "$ac_cv_prog_$1"; then | |
176 for ncn_progname in $2; do | |
177 AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) | |
178 done | |
179 fi | |
180 | |
181 if test -z "$ac_cv_prog_$1" && test -n "$with_build_time_tools"; then | |
182 for ncn_progname in $2; do | |
183 AC_MSG_CHECKING([for ${ncn_progname} in $with_build_time_tools]) | |
184 if test -x $with_build_time_tools/${ncn_progname}; then | |
185 ac_cv_prog_$1=$with_build_time_tools/${ncn_progname} | |
186 AC_MSG_RESULT(yes) | |
187 break | |
188 else | |
189 AC_MSG_RESULT(no) | |
190 fi | |
191 done | |
192 fi | |
193 | |
194 if test -z "$ac_cv_prog_$1"; then | |
195 for ncn_progname in $2; do | |
196 if test -n "$ncn_target_tool_prefix"; then | |
197 AC_CHECK_PROG([$1], [${ncn_target_tool_prefix}${ncn_progname}], | |
198 [${ncn_target_tool_prefix}${ncn_progname}], , [$4]) | |
199 fi | |
200 if test -z "$ac_cv_prog_$1" && test $build = $target ; then | |
201 AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) | |
202 fi | |
203 test -n "$ac_cv_prog_$1" && break | |
204 done | |
205 fi | |
206 | |
207 if test -z "$ac_cv_prog_$1" ; then | |
208 ifelse([$3],[], [set dummy $2 | |
209 if test $build = $target ; then | |
210 $1="[$]2" | |
211 else | |
212 $1="${ncn_target_tool_prefix}[$]2" | |
213 fi], [$1="$3"]) | |
214 else | |
215 $1="$ac_cv_prog_$1" | |
216 fi | |
217 ]) []dnl # NCN_STRICT_CHECK_TARGET_TOOLS | |
218 | |
219 | |
220 # Backported from Autoconf 2.5x; can go away when and if | |
221 # we switch. Put the OS path separator in $PATH_SEPARATOR. | |
222 AC_DEFUN([ACX_PATH_SEP], [ | |
223 # The user is always right. | |
224 if test "${PATH_SEPARATOR+set}" != set; then | |
225 echo "#! /bin/sh" >conf$$.sh | |
226 echo "exit 0" >>conf$$.sh | |
227 chmod +x conf$$.sh | |
228 if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then | |
229 PATH_SEPARATOR=';' | |
230 else | |
231 PATH_SEPARATOR=: | |
232 fi | |
233 rm -f conf$$.sh | |
234 fi | |
235 ]) | |
236 | |
237 | |
238 AC_DEFUN([ACX_TOOL_DIRS], [ | |
239 AC_REQUIRE([ACX_PATH_SEP]) | |
240 if test "x$exec_prefix" = xNONE; then | |
241 if test "x$prefix" = xNONE; then | |
242 gcc_cv_tool_prefix=$ac_default_prefix | |
243 else | |
244 gcc_cv_tool_prefix=$prefix | |
245 fi | |
246 else | |
247 gcc_cv_tool_prefix=$exec_prefix | |
248 fi | |
249 | |
250 # If there is no compiler in the tree, use the PATH only. In any | |
251 # case, if there is no compiler in the tree nobody should use | |
252 # AS_FOR_TARGET and LD_FOR_TARGET. | |
253 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then | |
254 gcc_version=`cat $srcdir/gcc/BASE-VER` | |
255 gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR" | |
256 gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR" | |
257 gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR" | |
258 gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR" | |
259 gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR" | |
260 gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR" | |
261 else | |
262 gcc_cv_tool_dirs= | |
263 fi | |
264 | |
265 if test x$build = x$target && test -n "$md_exec_prefix"; then | |
266 gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR" | |
267 fi | |
268 | |
269 ]) []dnl # ACX_TOOL_DIRS | |
270 | |
271 # ACX_HAVE_GCC_FOR_TARGET | |
272 # Check if the variable GCC_FOR_TARGET really points to a GCC binary. | |
273 AC_DEFUN([ACX_HAVE_GCC_FOR_TARGET], [ | |
274 cat > conftest.c << \EOF | |
275 #ifdef __GNUC__ | |
276 gcc_yay; | |
277 #endif | |
278 EOF | |
279 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then | |
280 have_gcc_for_target=yes | |
281 else | |
282 GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc | |
283 have_gcc_for_target=no | |
284 fi | |
285 rm conftest.c | |
286 ]) | |
287 | |
288 # ACX_CHECK_INSTALLED_TARGET_TOOL(VAR, PROG) | |
289 # Searching for installed target binutils. We need to take extra care, | |
290 # else we may find the wrong assembler, linker, etc., and lose. | |
291 # | |
292 # First try --with-build-time-tools, if specified. | |
293 # | |
294 # For build != host, we ask the installed GCC for the name of the tool it | |
295 # uses, and accept it if it is an absolute path. This is because the | |
296 # only good choice for a compiler is the same GCC version that is being | |
297 # installed (or we couldn't make target libraries), and we assume that | |
298 # on the host system we'll have not only the same GCC version, but also | |
299 # the same binutils version. | |
300 # | |
301 # For build == host, search the same directories that the installed | |
302 # compiler will search. We used to do this for the assembler, linker, | |
303 # and nm only; for simplicity of configuration, however, we extend this | |
304 # criterion to tools (such as ar and ranlib) that are never invoked by | |
305 # the compiler, to avoid mismatches. | |
306 # | |
307 # Also note we have to check MD_EXEC_PREFIX before checking the user's path | |
308 # if build == target. This makes the most sense only when bootstrapping, | |
309 # but we also do so when build != host. In this case, we hope that the | |
310 # build and host systems will have similar contents of MD_EXEC_PREFIX. | |
311 # | |
312 # If we do not find a suitable binary, then try the user's path. | |
313 | |
314 AC_DEFUN([ACX_CHECK_INSTALLED_TARGET_TOOL], [ | |
315 AC_REQUIRE([ACX_TOOL_DIRS]) | |
316 AC_REQUIRE([ACX_HAVE_GCC_FOR_TARGET]) | |
317 if test -z "$ac_cv_path_$1" ; then | |
318 if test -n "$with_build_time_tools"; then | |
319 AC_MSG_CHECKING([for $2 in $with_build_time_tools]) | |
320 if test -x $with_build_time_tools/$2; then | |
321 $1=`cd $with_build_time_tools && pwd`/$2 | |
322 ac_cv_path_$1=[$]$1 | |
323 AC_MSG_RESULT([$ac_cv_path_$1]) | |
324 else | |
325 AC_MSG_RESULT(no) | |
326 fi | |
327 elif test $build != $host && test $have_gcc_for_target = yes; then | |
328 $1=`$GCC_FOR_TARGET --print-prog-name=$2` | |
329 test [$]$1 = $2 && $1= | |
330 test -n "[$]$1" && ac_cv_path_$1=[$]$1 | |
331 fi | |
332 fi | |
333 if test -z "$ac_cv_path_$1" && test -n "$gcc_cv_tool_dirs"; then | |
334 AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs]) | |
335 fi | |
336 if test -z "$ac_cv_path_$1" ; then | |
337 NCN_STRICT_CHECK_TARGET_TOOLS([$1], [$2]) | |
338 else | |
339 $1=$ac_cv_path_$1 | |
340 fi | |
341 ]) []dnl # ACX_CHECK_INSTALLED_TARGET_TOOL | |
342 | |
343 ### | |
344 # AC_PROG_CPP_WERROR | |
345 # Used for autoconf 2.5x to force AC_PREPROC_IFELSE to reject code which | |
346 # triggers warnings from the preprocessor. Will be in autoconf 2.58. | |
347 # For now, using this also overrides header checks to use only the | |
348 # preprocessor (matches 2.13 behavior; matching 2.58's behavior is a | |
349 # bit harder from here). | |
350 # Eventually autoconf will default to checking headers with the compiler | |
351 # instead, and we'll have to do this differently. | |
352 | |
353 AC_DEFUN([AC_PROG_CPP_WERROR], | |
354 [AC_REQUIRE([AC_PROG_CPP])dnl | |
355 m4_define([AC_CHECK_HEADER],m4_defn([_AC_CHECK_HEADER_OLD])) | |
356 ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR | |
357 | |
358 # Test for GNAT. | |
359 # We require the gnatbind program, and a compiler driver that | |
360 # understands Ada. We use the user's CC setting, already found, | |
361 # and possibly add $1 to the command-line parameters. | |
362 # | |
363 # Sets the shell variable have_gnat to yes or no as appropriate, and | |
364 # substitutes GNATBIND and GNATMAKE. | |
365 AC_DEFUN([ACX_PROG_GNAT], | |
366 [AC_REQUIRE([AC_CHECK_TOOL_PREFIX]) | |
367 AC_REQUIRE([AC_PROG_CC]) | |
368 AC_CHECK_TOOL(GNATBIND, gnatbind, no) | |
369 AC_CHECK_TOOL(GNATMAKE, gnatmake, no) | |
370 AC_CACHE_CHECK([whether compiler driver understands Ada], | |
371 acx_cv_cc_gcc_supports_ada, | |
372 [cat >conftest.adb <<EOF | |
373 procedure conftest is begin null; end conftest; | |
374 EOF | |
375 acx_cv_cc_gcc_supports_ada=no | |
376 # There is a bug in old released versions of GCC which causes the | |
377 # driver to exit successfully when the appropriate language module | |
378 # has not been installed. This is fixed in 2.95.4, 3.0.2, and 3.1. | |
379 # Therefore we must check for the error message as well as an | |
380 # unsuccessful exit. | |
381 # Other compilers, like HP Tru64 UNIX cc, exit successfully when | |
382 # given a .adb file, but produce no object file. So we must check | |
383 # if an object file was really produced to guard against this. | |
384 errors=`(${CC} $1[]m4_ifval([$1], [ ])-c conftest.adb) 2>&1 || echo failure` | |
385 if test x"$errors" = x && test -f conftest.$ac_objext; then | |
386 acx_cv_cc_gcc_supports_ada=yes | |
387 fi | |
388 rm -f conftest.*]) | |
389 | |
390 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then | |
391 have_gnat=yes | |
392 else | |
393 have_gnat=no | |
394 fi | |
395 ]) | |
396 | |
397 dnl 'make compare' can be significantly faster, if cmp itself can | |
398 dnl skip bytes instead of using tail. The test being performed is | |
399 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2" | |
400 dnl but we need to sink errors and handle broken shells. We also test | |
401 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is | |
402 dnl accepted by cmp on some systems. | |
403 AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL], | |
404 [AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip, | |
405 [ echo abfoo >t1 | |
406 echo cdfoo >t2 | |
407 gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2' | |
408 if cmp t1 t2 2 2 > /dev/null 2>&1; then | |
409 if cmp t1 t2 1 1 > /dev/null 2>&1; then | |
410 : | |
411 else | |
412 gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16' | |
413 fi | |
414 fi | |
415 if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then | |
416 if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then | |
417 : | |
418 else | |
419 gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2' | |
420 fi | |
421 fi | |
422 rm t1 t2 | |
423 ]) | |
424 do_compare="$gcc_cv_prog_cmp_skip" | |
425 AC_SUBST(do_compare) | |
426 ]) | |
427 | |
428 dnl See whether we can include both string.h and strings.h. | |
429 AC_DEFUN([ACX_HEADER_STRING], | |
430 [AC_CACHE_CHECK([whether string.h and strings.h may both be included], | |
431 gcc_cv_header_string, | |
432 [AC_TRY_COMPILE([#include <string.h> | |
433 #include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)]) | |
434 if test $gcc_cv_header_string = yes; then | |
435 AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.]) | |
436 fi | |
437 ]) | |
438 | |
439 dnl See if stdbool.h properly defines bool and true/false. | |
440 dnl Check whether _Bool is built-in. | |
441 AC_DEFUN([ACX_HEADER_STDBOOL], | |
442 [AC_CACHE_CHECK([for working stdbool.h], | |
443 ac_cv_header_stdbool_h, | |
444 [AC_TRY_COMPILE([#include <stdbool.h>], | |
445 [bool foo = false;], | |
446 ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)]) | |
447 if test $ac_cv_header_stdbool_h = yes; then | |
448 AC_DEFINE(HAVE_STDBOOL_H, 1, | |
449 [Define if you have a working <stdbool.h> header file.]) | |
450 fi | |
451 AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool, | |
452 [AC_TRY_COMPILE(, | |
453 [_Bool foo;], | |
454 gcc_cv_c__bool=yes, gcc_cv_c__bool=no) | |
455 ]) | |
456 if test $gcc_cv_c__bool = yes; then | |
457 AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.]) | |
458 fi | |
459 ]) | |
460 | |
461 dnl See if hard links work and if not, try to substitute $1 or simple copy. | |
462 AC_DEFUN([ACX_PROG_LN], | |
463 [AC_MSG_CHECKING(whether ln works) | |
464 AC_CACHE_VAL(acx_cv_prog_LN, | |
465 [rm -f conftestdata_t | |
466 echo >conftestdata_f | |
467 if ln conftestdata_f conftestdata_t 2>/dev/null | |
468 then | |
469 acx_cv_prog_LN=ln | |
470 else | |
471 acx_cv_prog_LN=no | |
472 fi | |
473 rm -f conftestdata_f conftestdata_t | |
474 ])dnl | |
475 if test $acx_cv_prog_LN = no; then | |
476 LN="ifelse([$1],,cp,[$1])" | |
477 AC_MSG_RESULT([no, using $LN]) | |
478 else | |
479 LN="$acx_cv_prog_LN" | |
480 AC_MSG_RESULT(yes) | |
481 fi | |
482 AC_SUBST(LN)dnl | |
483 ]) | |
484 | |
485 dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE) | |
486 AC_DEFUN([GCC_TARGET_TOOL], | |
487 [AC_MSG_CHECKING(where to find the target $1) | |
488 if test "x${build}" != "x${host}" ; then | |
489 if expr "x[$]$2" : "x/" > /dev/null; then | |
490 # We already found the complete path | |
491 ac_dir=`dirname [$]$2` | |
492 AC_MSG_RESULT(pre-installed in $ac_dir) | |
493 else | |
494 # Canadian cross, just use what we found | |
495 AC_MSG_RESULT(pre-installed) | |
496 fi | |
497 else | |
498 ifelse([$4],,, | |
499 [ok=yes | |
500 case " ${configdirs} " in | |
501 *" patsubst([$4], [/.*], []) "*) ;; | |
502 *) ok=no ;; | |
503 esac | |
504 ifelse([$5],,, | |
505 [case ,${enable_languages}, in | |
506 *,$5,*) ;; | |
507 *) ok=no ;; | |
508 esac]) | |
509 if test $ok = yes; then | |
510 # An in-tree tool is available and we can use it | |
511 $2='$$r/$(HOST_SUBDIR)/$4' | |
512 AC_MSG_RESULT(just compiled) | |
513 el])if expr "x[$]$2" : "x/" > /dev/null; then | |
514 # We already found the complete path | |
515 ac_dir=`dirname [$]$2` | |
516 AC_MSG_RESULT(pre-installed in $ac_dir) | |
517 elif test "x$target" = "x$host"; then | |
518 # We can use an host tool | |
519 $2='$($3)' | |
520 AC_MSG_RESULT(host tool) | |
521 else | |
522 # We need a cross tool | |
523 AC_MSG_RESULT(pre-installed) | |
524 fi | |
525 fi | |
526 AC_SUBST($2)]) | |
527 | |
528 | |
529 dnl Locate a program and check that its version is acceptable. | |
530 dnl ACX_PROG_CHECK_VER(var, name, version-switch, | |
531 dnl version-extract-regexp, version-glob) | |
532 AC_DEFUN([ACX_CHECK_PROG_VER],[ | |
533 AC_CHECK_PROG([$1], [$2], [$2]) | |
534 if test -n "[$]$1"; then | |
535 # Found it, now check the version. | |
536 AC_CACHE_CHECK([for modern $2], | |
537 [gcc_cv_prog_$2_modern], | |
538 [ac_prog_version=`eval [$]$1 $3 2>&1 | | |
539 sed -n 's/^.*patsubst([[$4]],/,\/).*$/\1/p'` | |
540 | |
541 [case $ac_prog_version in | |
542 '') gcc_cv_prog_$2_modern=no;; | |
543 $5) gcc_cv_prog_$2_modern=yes;; | |
544 *) gcc_cv_prog_$2_modern=no;; | |
545 esac] | |
546 ]) | |
547 else | |
548 gcc_cv_prog_$2_modern=no | |
549 fi | |
550 if test $gcc_cv_prog_$2_modern = no; then | |
551 $1="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing $2" | |
552 fi | |
553 ]) | |
554 | |
555 dnl Support the --with-pkgversion configure option. | |
556 dnl ACX_PKGVERSION(default-pkgversion) | |
557 AC_DEFUN([ACX_PKGVERSION],[ | |
558 AC_ARG_WITH(pkgversion, | |
559 AS_HELP_STRING([--with-pkgversion=PKG], | |
560 [Use PKG in the version string in place of "$1"]), | |
561 [case "$withval" in | |
562 yes) AC_MSG_ERROR([package version not specified]) ;; | |
563 no) PKGVERSION= ;; | |
564 *) PKGVERSION="($withval) " ;; | |
565 esac], | |
566 PKGVERSION="($1) " | |
567 ) | |
568 AC_SUBST(PKGVERSION) | |
569 ]) | |
570 | |
571 dnl Support the --with-bugurl configure option. | |
572 dnl ACX_BUGURL(default-bugurl) | |
573 AC_DEFUN([ACX_BUGURL],[ | |
574 AC_ARG_WITH(bugurl, | |
575 AS_HELP_STRING([--with-bugurl=URL], | |
576 [Direct users to URL to report a bug]), | |
577 [case "$withval" in | |
578 yes) AC_MSG_ERROR([bug URL not specified]) ;; | |
579 no) BUGURL= | |
580 ;; | |
581 *) BUGURL="$withval" | |
582 ;; | |
583 esac], | |
584 BUGURL="$1" | |
585 ) | |
586 case ${BUGURL} in | |
587 "") | |
588 REPORT_BUGS_TO= | |
589 REPORT_BUGS_TEXI= | |
590 ;; | |
591 *) | |
592 REPORT_BUGS_TO="<$BUGURL>" | |
593 REPORT_BUGS_TEXI=@uref{`echo "$BUGURL" | sed 's/@/@@/g'`} | |
594 ;; | |
595 esac; | |
596 AC_SUBST(REPORT_BUGS_TO) | |
597 AC_SUBST(REPORT_BUGS_TEXI) | |
598 ]) | |
599 | |
600 dnl #### | |
601 dnl # ACX_CHECK_CYGWIN_CAT_WORKS | |
602 dnl # On Cygwin hosts, check that the cat command ignores | |
603 dnl # carriage returns as otherwise builds will not work. | |
604 dnl # See binutils PR 4334 for more details. | |
605 AC_DEFUN([ACX_CHECK_CYGWIN_CAT_WORKS],[ | |
606 AC_MSG_CHECKING([to see if cat works as expected]) | |
607 echo a >cygwin-cat-check | |
608 if test `cat cygwin-cat-check` == a ; then | |
609 rm cygwin-cat-check | |
610 AC_MSG_RESULT(yes) | |
611 else | |
612 rm cygwin-cat-check | |
613 AC_MSG_RESULT(no) | |
614 AC_MSG_ERROR([The cat command does not ignore carriage return characters. | |
615 Please either mount the build directory in binary mode or run the following | |
616 commands before running any configure script: | |
617 set -o igncr | |
618 export SHELLOPTS | |
619 ]) | |
620 fi | |
621 ]) |