OSDN Git Service

a8970759f5ca0b096e048256772447a601e98e37
[pf3gnuchains/gcc-fork.git] / config / acx.m4
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 fi
215 ]) []dnl # NCN_STRICT_CHECK_TARGET_TOOLS
216   
217
218 # Backported from Autoconf 2.5x; can go away when and if
219 # we switch.  Put the OS path separator in $PATH_SEPARATOR.
220 AC_DEFUN([ACX_PATH_SEP], [
221 # The user is always right.
222 if test "${PATH_SEPARATOR+set}" != set; then
223   echo "#! /bin/sh" >conf$$.sh
224   echo  "exit 0"   >>conf$$.sh
225   chmod +x conf$$.sh
226   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
227     PATH_SEPARATOR=';'
228   else
229     PATH_SEPARATOR=: 
230   fi
231   rm -f conf$$.sh
232 fi
233 ])
234
235
236 AC_DEFUN([ACX_TOOL_DIRS], [
237 AC_REQUIRE([ACX_PATH_SEP])
238 if test "x$exec_prefix" = xNONE; then
239         if test "x$prefix" = xNONE; then
240                 gcc_cv_tool_prefix=$ac_default_prefix
241         else
242                 gcc_cv_tool_prefix=$prefix
243         fi
244 else
245         gcc_cv_tool_prefix=$exec_prefix
246 fi
247
248 # If there is no compiler in the tree, use the PATH only.  In any
249 # case, if there is no compiler in the tree nobody should use
250 # AS_FOR_TARGET and LD_FOR_TARGET.
251 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
252     gcc_version=`cat $srcdir/gcc/BASE-VER`
253     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
254     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
255     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
256     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
257     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
258     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
259 else
260     gcc_cv_tool_dirs=
261 fi
262
263 if test x$build = x$target && test -n "$md_exec_prefix"; then
264         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
265 fi
266
267 ]) []dnl # ACX_TOOL_DIRS
268
269 # ACX_HAVE_GCC_FOR_TARGET
270 # Check if the variable GCC_FOR_TARGET really points to a GCC binary.
271 AC_DEFUN([ACX_HAVE_GCC_FOR_TARGET], [
272 cat > conftest.c << \EOF
273 #ifdef __GNUC__
274   gcc_yay;
275 #endif
276 EOF
277 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
278   have_gcc_for_target=yes
279 else
280   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
281   have_gcc_for_target=no
282 fi
283 rm conftest.c
284 ])
285
286 # ACX_CHECK_INSTALLED_TARGET_TOOL(VAR, PROG)
287 # Searching for installed target binutils.  We need to take extra care,
288 # else we may find the wrong assembler, linker, etc., and lose.
289 #
290 # First try --with-build-time-tools, if specified.
291 #
292 # For build != host, we ask the installed GCC for the name of the tool it
293 # uses, and accept it if it is an absolute path.  This is because the
294 # only good choice for a compiler is the same GCC version that is being
295 # installed (or we couldn't make target libraries), and we assume that
296 # on the host system we'll have not only the same GCC version, but also
297 # the same binutils version.
298 #
299 # For build == host, search the same directories that the installed
300 # compiler will search.  We used to do this for the assembler, linker,
301 # and nm only; for simplicity of configuration, however, we extend this
302 # criterion to tools (such as ar and ranlib) that are never invoked by
303 # the compiler, to avoid mismatches.
304 #
305 # Also note we have to check MD_EXEC_PREFIX before checking the user's path
306 # if build == target.  This makes the most sense only when bootstrapping,
307 # but we also do so when build != host.  In this case, we hope that the
308 # build and host systems will have similar contents of MD_EXEC_PREFIX.
309 #
310 # If we do not find a suitable binary, then try the user's path.
311
312 AC_DEFUN([ACX_CHECK_INSTALLED_TARGET_TOOL], [
313 AC_REQUIRE([ACX_TOOL_DIRS])
314 AC_REQUIRE([ACX_HAVE_GCC_FOR_TARGET])
315 if test -z "$ac_cv_path_$1" ; then
316   if test -n "$with_build_time_tools"; then
317     AC_MSG_CHECKING([for $2 in $with_build_time_tools])
318     if test -x $with_build_time_tools/$2; then
319       $1=`cd $with_build_time_tools && pwd`/$2
320       ac_cv_path_$1=[$]$1
321       AC_MSG_RESULT([$ac_cv_path_$1])
322     else
323       AC_MSG_RESULT(no)
324     fi
325   elif test $build != $host && test $have_gcc_for_target = yes; then
326     $1=`$GCC_FOR_TARGET --print-prog-name=$2`
327     test [$]$1=$2 && $1=
328     ac_cv_path_$1=[$]$1
329   fi
330 fi
331 if test -z "$ac_cv_path_$1" && test -n "$gcc_cv_tool_dirs"; then
332   AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs])
333 fi
334 if test -z "$ac_cv_path_$1" ; then
335   NCN_STRICT_CHECK_TARGET_TOOLS([$1], [$2])
336 else
337   $1=$ac_cv_path_$1
338 fi
339 ]) []dnl # ACX_CHECK_INSTALLED_TARGET_TOOL
340
341 ###
342 # AC_PROG_CPP_WERROR
343 # Used for autoconf 2.5x to force AC_PREPROC_IFELSE to reject code which
344 # triggers warnings from the preprocessor.  Will be in autoconf 2.58.
345 # For now, using this also overrides header checks to use only the
346 # preprocessor (matches 2.13 behavior; matching 2.58's behavior is a
347 # bit harder from here).
348 # Eventually autoconf will default to checking headers with the compiler
349 # instead, and we'll have to do this differently.
350
351 AC_DEFUN([AC_PROG_CPP_WERROR],
352 [AC_REQUIRE([AC_PROG_CPP])dnl
353 m4_define([AC_CHECK_HEADER],m4_defn([_AC_CHECK_HEADER_OLD]))
354 ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR
355
356 # Test for GNAT.
357 # We require the gnatbind program, and a compiler driver that
358 # understands Ada.  We use the user's CC setting, already found.
359 #
360 # Sets the shell variable have_gnat to yes or no as appropriate, and
361 # substitutes GNATBIND and GNATMAKE.
362 AC_DEFUN([ACX_PROG_GNAT],
363 [AC_REQUIRE([AC_CHECK_TOOL_PREFIX])
364 AC_REQUIRE([AC_PROG_CC])
365 AC_CHECK_TOOL(GNATBIND, gnatbind, no)
366 AC_CHECK_TOOL(GNATMAKE, gnatmake, no)
367 AC_CACHE_CHECK([whether compiler driver understands Ada],
368                  acx_cv_cc_gcc_supports_ada,
369 [cat >conftest.adb <<EOF
370 procedure conftest is begin null; end conftest;
371 EOF
372 acx_cv_cc_gcc_supports_ada=no
373 # There is a bug in old released versions of GCC which causes the
374 # driver to exit successfully when the appropriate language module
375 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
376 # Therefore we must check for the error message as well as an
377 # unsuccessful exit.
378 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
379 # given a .adb file, but produce no object file.  So we must check
380 # if an object file was really produced to guard against this.
381 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
382 if test x"$errors" = x && test -f conftest.$ac_objext; then
383   acx_cv_cc_gcc_supports_ada=yes
384 fi
385 rm -f conftest.*])
386
387 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
388   have_gnat=yes
389 else
390   have_gnat=no
391 fi
392 ])
393
394 dnl 'make compare' can be significantly faster, if cmp itself can
395 dnl skip bytes instead of using tail.  The test being performed is
396 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
397 dnl but we need to sink errors and handle broken shells.  We also test
398 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
399 dnl accepted by cmp on some systems.
400 AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL],
401 [AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip,
402 [ echo abfoo >t1
403   echo cdfoo >t2
404   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
405   if cmp t1 t2 2 2 > /dev/null 2>&1; then
406     if cmp t1 t2 1 1 > /dev/null 2>&1; then
407       :
408     else
409       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
410     fi
411   fi
412   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
413     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
414       :
415     else
416       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
417     fi
418   fi
419   rm t1 t2
420 ])
421 do_compare="$gcc_cv_prog_cmp_skip"
422 AC_SUBST(do_compare)
423 ])
424
425 dnl See whether we can include both string.h and strings.h.
426 AC_DEFUN([ACX_HEADER_STRING],
427 [AC_CACHE_CHECK([whether string.h and strings.h may both be included],
428   gcc_cv_header_string,
429 [AC_TRY_COMPILE([#include <string.h>
430 #include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)])
431 if test $gcc_cv_header_string = yes; then
432   AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.])
433 fi
434 ])
435
436 dnl See if stdbool.h properly defines bool and true/false.
437 dnl Check whether _Bool is built-in.
438 AC_DEFUN([ACX_HEADER_STDBOOL],
439 [AC_CACHE_CHECK([for working stdbool.h],
440   ac_cv_header_stdbool_h,
441 [AC_TRY_COMPILE([#include <stdbool.h>],
442 [bool foo = false;],
443 ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)])
444 if test $ac_cv_header_stdbool_h = yes; then
445   AC_DEFINE(HAVE_STDBOOL_H, 1,
446   [Define if you have a working <stdbool.h> header file.])
447 fi
448 AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool,
449 [AC_TRY_COMPILE(,
450 [_Bool foo;],
451 gcc_cv_c__bool=yes, gcc_cv_c__bool=no)
452 ])
453 if test $gcc_cv_c__bool = yes; then
454   AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.])
455 fi
456 ])
457
458 dnl See if hard links work and if not, try to substitute $1 or simple copy.
459 AC_DEFUN([ACX_PROG_LN],
460 [AC_MSG_CHECKING(whether ln works)
461 AC_CACHE_VAL(acx_cv_prog_LN,
462 [rm -f conftestdata_t
463 echo >conftestdata_f
464 if ln conftestdata_f conftestdata_t 2>/dev/null
465 then
466   acx_cv_prog_LN=ln
467 else
468   acx_cv_prog_LN=no
469 fi
470 rm -f conftestdata_f conftestdata_t
471 ])dnl
472 if test $acx_cv_prog_LN = no; then
473   LN="ifelse([$1],,cp,[$1])"
474   AC_MSG_RESULT([no, using $LN])
475 else
476   LN="$acx_cv_prog_LN"
477   AC_MSG_RESULT(yes)
478 fi
479 AC_SUBST(LN)dnl
480 ])
481
482 dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE)
483 AC_DEFUN([GCC_TARGET_TOOL],
484 [AC_MSG_CHECKING(where to find the target $1)
485 if test "x${build}" != "x${host}" ; then
486   if expr "x[$]$2" : "x/" > /dev/null; then
487     # We already found the complete path
488     ac_dir=`dirname [$]$2`
489     AC_MSG_RESULT(pre-installed in $ac_dir)
490   else
491     # Canadian cross, just use what we found
492     AC_MSG_RESULT(pre-installed)
493   fi
494 else
495   ifelse([$4],,,
496   [ok=yes
497   case " ${configdirs} " in
498     *" patsubst([$4], [/.*], []) "*) ;;
499     *) ok=no ;;
500   esac
501   ifelse([$5],,, 
502   [case ,${enable_languages}, in
503     *,$5,*) ;;
504     *) ok=no ;;
505   esac])
506   if test $ok = yes; then
507     # An in-tree tool is available and we can use it
508     $2='$$r/$(HOST_SUBDIR)/$4'
509     AC_MSG_RESULT(just compiled)
510   el])if expr "x[$]$2" : "x/" > /dev/null; then
511     # We already found the complete path
512     ac_dir=`dirname [$]$2`
513     AC_MSG_RESULT(pre-installed in $ac_dir)
514   elif test "x$target" = "x$host"; then
515     # We can use an host tool
516     $2='$($3)'
517     AC_MSG_RESULT(host tool)
518   else
519     # We need a cross tool
520     AC_MSG_RESULT(pre-installed)
521   fi
522 fi
523 AC_SUBST($2)])
524
525
526 dnl Locate a program and check that its version is acceptable.
527 dnl ACX_PROG_CHECK_VER(var, name, version-switch,
528 dnl                    version-extract-regexp, version-glob)
529 AC_DEFUN([ACX_CHECK_PROG_VER],[
530   AC_CHECK_PROG([$1], [$2], [$2])
531   if test -n "[$]$1"; then
532     # Found it, now check the version.
533     AC_CACHE_CHECK([for modern $2],
534                    [gcc_cv_prog_$2_modern],
535                    [ac_prog_version=`eval [$]$1 $3 2>&1 |
536                                      sed -n 's/^.*patsubst([[$4]],/,\/).*$/\1/p'`
537
538                     [case $ac_prog_version in
539                       '')  gcc_cv_prog_$2_modern=no;;
540                       $5)  gcc_cv_prog_$2_modern=yes;;
541                       *)   gcc_cv_prog_$2_modern=no;;
542                     esac]
543
544                     if test $gcc_cv_prog_$2_modern = no; then
545                       $1="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing $2"
546                     fi
547                    ])
548   else
549     gcc_cv_prog_$2_modern=no
550   fi
551   if test $gcc_cv_prog_$2_modern = no; then
552     $1="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing $2"
553   fi
554 ])