Daily bump.
[official-gcc.git] / config / acx.m4
blobaa1d34b2b4962abe22cddd6b65ff05446056986f
1 # Autoconf M4 include file defining utility macros for complex Canadian
2 # cross builds.
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
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
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
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
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
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
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
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.
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=.
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
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
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.
124 AC_DEFUN([NCN_STRICT_CHECK_TOOLS],
125 [AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl
126 AC_ARG_VAR([$1], [$1 for the host])
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
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
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
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"])
159 ]) []dnl # NCN_STRICT_CHECK_TOOLS
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.
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])
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
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
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
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
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"
217 ]) []dnl # NCN_STRICT_CHECK_TARGET_TOOLS
218   
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
238 dnl ####
239 dnl # GCC_BASE_VER
240 dnl # Determine GCC version number to use in compiler directories.
242 AC_DEFUN([GCC_BASE_VER],
244   get_gcc_base_ver="cat"
245   AC_ARG_WITH(gcc-major-version-only,
246   [AS_HELP_STRING([--with-gcc-major-version-only], [use only GCC major number in filesystem paths])],
247   [if test x$with_gcc_major_version_only = xyes ; then
248     changequote(,)dnl
249     get_gcc_base_ver="sed -e 's/^\([0-9]*\).*\$\$/\1/'"
250     changequote([,])dnl
251   fi
252   ])
253   AC_SUBST(get_gcc_base_ver)
257 AC_DEFUN([ACX_TOOL_DIRS], [
258 AC_REQUIRE([ACX_PATH_SEP])
259 AC_REQUIRE([GCC_BASE_VER])
260 if test "x$exec_prefix" = xNONE; then
261         if test "x$prefix" = xNONE; then
262                 gcc_cv_tool_prefix=$ac_default_prefix
263         else
264                 gcc_cv_tool_prefix=$prefix
265         fi
266 else
267         gcc_cv_tool_prefix=$exec_prefix
270 # If there is no compiler in the tree, use the PATH only.  In any
271 # case, if there is no compiler in the tree nobody should use
272 # AS_FOR_TARGET and LD_FOR_TARGET.
273 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
274     if test x$with_gcc_major_version_only = xyes ; then
275         changequote(,)dnl
276         gcc_version=`sed -e 's/^\([0-9]*\).*$/\1/' $srcdir/gcc/BASE-VER`
277         changequote([,])dnl
278     else
279         gcc_version=`cat $srcdir/gcc/BASE-VER`
280     fi
281     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
282     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
283     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
284     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
285     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
286     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
287 else
288     gcc_cv_tool_dirs=
291 if test x$build = x$target && test -n "$md_exec_prefix"; then
292         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
295 ]) []dnl # ACX_TOOL_DIRS
297 # ACX_HAVE_GCC_FOR_TARGET
298 # Check if the variable GCC_FOR_TARGET really points to a GCC binary.
299 AC_DEFUN([ACX_HAVE_GCC_FOR_TARGET], [
300 cat > conftest.c << \EOF
301 #ifdef __GNUC__
302   gcc_yay;
303 #endif
305 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
306   have_gcc_for_target=yes
307 else
308   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
309   have_gcc_for_target=no
311 rm conftest.c
314 # ACX_CHECK_INSTALLED_TARGET_TOOL(VAR, PROG)
315 # Searching for installed target binutils.  We need to take extra care,
316 # else we may find the wrong assembler, linker, etc., and lose.
318 # First try --with-build-time-tools, if specified.
320 # For build != host, we ask the installed GCC for the name of the tool it
321 # uses, and accept it if it is an absolute path.  This is because the
322 # only good choice for a compiler is the same GCC version that is being
323 # installed (or we couldn't make target libraries), and we assume that
324 # on the host system we'll have not only the same GCC version, but also
325 # the same binutils version.
327 # For build == host, search the same directories that the installed
328 # compiler will search.  We used to do this for the assembler, linker,
329 # and nm only; for simplicity of configuration, however, we extend this
330 # criterion to tools (such as ar and ranlib) that are never invoked by
331 # the compiler, to avoid mismatches.
333 # Also note we have to check MD_EXEC_PREFIX before checking the user's path
334 # if build == target.  This makes the most sense only when bootstrapping,
335 # but we also do so when build != host.  In this case, we hope that the
336 # build and host systems will have similar contents of MD_EXEC_PREFIX.
338 # If we do not find a suitable binary, then try the user's path.
340 AC_DEFUN([ACX_CHECK_INSTALLED_TARGET_TOOL], [
341 AC_REQUIRE([ACX_TOOL_DIRS])
342 AC_REQUIRE([ACX_HAVE_GCC_FOR_TARGET])
343 if test -z "$ac_cv_path_$1" ; then
344   if test -n "$with_build_time_tools"; then
345     AC_MSG_CHECKING([for $2 in $with_build_time_tools])
346     if test -x $with_build_time_tools/$2; then
347       $1=`cd $with_build_time_tools && pwd`/$2
348       ac_cv_path_$1=[$]$1
349       AC_MSG_RESULT([$ac_cv_path_$1])
350     else
351       AC_MSG_RESULT(no)
352     fi
353   elif test $build != $host && test $have_gcc_for_target = yes; then
354     $1=`$GCC_FOR_TARGET --print-prog-name=$2`
355     test [$]$1 = $2 && $1=
356     test -n "[$]$1" && ac_cv_path_$1=[$]$1
357   fi
359 if test -z "$ac_cv_path_$1" && test -n "$gcc_cv_tool_dirs"; then
360   AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs])
362 if test -z "$ac_cv_path_$1" ; then
363   NCN_STRICT_CHECK_TARGET_TOOLS([$1], [$2])
364 else
365   $1=$ac_cv_path_$1
367 ]) []dnl # ACX_CHECK_INSTALLED_TARGET_TOOL
370 # AC_PROG_CPP_WERROR
371 # Used for autoconf 2.5x to force AC_PREPROC_IFELSE to reject code which
372 # triggers warnings from the preprocessor.  Will be in autoconf 2.58.
373 # For now, using this also overrides header checks to use only the
374 # preprocessor (matches 2.13 behavior; matching 2.58's behavior is a
375 # bit harder from here).
376 # Eventually autoconf will default to checking headers with the compiler
377 # instead, and we'll have to do this differently.
379 AC_DEFUN([AC_PROG_CPP_WERROR],
380 [AC_REQUIRE([AC_PROG_CPP])dnl
381 m4_define([AC_CHECK_HEADER],m4_defn([_AC_CHECK_HEADER_OLD]))
382 ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR
384 # Test for GNAT.
385 # We require the gnatbind & gnatmake programs, as well as a compiler driver
386 # that understands Ada.  We use the user's CC setting, already found, and
387 # possibly add $1 to the command-line parameters.
389 # Sets the shell variable have_gnat to yes or no as appropriate, and
390 # substitutes GNATBIND and GNATMAKE.
391 AC_DEFUN([ACX_PROG_GNAT],
392 [AC_REQUIRE([AC_CHECK_TOOL_PREFIX])
393 AC_REQUIRE([AC_PROG_CC])
394 AC_CHECK_TOOL(GNATBIND, gnatbind, no)
395 AC_CHECK_TOOL(GNATMAKE, gnatmake, no)
396 AC_CACHE_CHECK([whether compiler driver understands Ada],
397                  acx_cv_cc_gcc_supports_ada,
398 [cat >conftest.adb <<EOF
399 procedure conftest is begin null; end conftest;
401 acx_cv_cc_gcc_supports_ada=no
402 # There is a bug in old released versions of GCC which causes the
403 # driver to exit successfully when the appropriate language module
404 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
405 # Therefore we must check for the error message as well as an
406 # unsuccessful exit.
407 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
408 # given a .adb file, but produce no object file.  So we must check
409 # if an object file was really produced to guard against this.
410 errors=`(${CC} $1[]m4_ifval([$1], [ ])-c conftest.adb) 2>&1 || echo failure`
411 if test x"$errors" = x && test -f conftest.$ac_objext; then
412   acx_cv_cc_gcc_supports_ada=yes
414 rm -f conftest.*])
416 if test "x$GNATBIND" != xno && test "x$GNATMAKE" != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
417   have_gnat=yes
418 else
419   have_gnat=no
423 dnl 'make compare' can be significantly faster, if cmp itself can
424 dnl skip bytes instead of using tail.  The test being performed is
425 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
426 dnl but we need to sink errors and handle broken shells.  We also test
427 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
428 dnl accepted by cmp on some systems.
429 AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL],
430 [AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip,
431 [ echo abfoo >t1
432   echo cdfoo >t2
433   gcc_cv_prog_cmp_skip='tail -c +17 $$f1 > tmp-foo1; tail -c +17 $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
434   if cmp t1 t2 2 2 > /dev/null 2>&1; then
435     if cmp t1 t2 1 1 > /dev/null 2>&1; then
436       :
437     else
438       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
439     fi
440   fi
441   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
442     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
443       :
444     else
445       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
446     fi
447   fi
448   rm t1 t2
450 do_compare="$gcc_cv_prog_cmp_skip"
451 AC_SUBST(do_compare)
454 dnl See whether we can include both string.h and strings.h.
455 AC_DEFUN([ACX_HEADER_STRING],
456 [AC_CACHE_CHECK([whether string.h and strings.h may both be included],
457   gcc_cv_header_string,
458 [AC_TRY_COMPILE([#include <string.h>
459 #include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)])
460 if test $gcc_cv_header_string = yes; then
461   AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.])
465 dnl See if stdbool.h properly defines bool and true/false.
466 dnl Check whether _Bool is built-in.
467 AC_DEFUN([ACX_HEADER_STDBOOL],
468 [AC_CACHE_CHECK([for working stdbool.h],
469   ac_cv_header_stdbool_h,
470 [AC_TRY_COMPILE([#include <stdbool.h>],
471 [bool foo = false;],
472 ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)])
473 if test $ac_cv_header_stdbool_h = yes; then
474   AC_DEFINE(HAVE_STDBOOL_H, 1,
475   [Define if you have a working <stdbool.h> header file.])
477 AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool,
478 [AC_TRY_COMPILE(,
479 [_Bool foo;],
480 gcc_cv_c__bool=yes, gcc_cv_c__bool=no)
482 if test $gcc_cv_c__bool = yes; then
483   AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.])
487 dnl See if hard links work and if not, try to substitute $1 or simple copy.
488 AC_DEFUN([ACX_PROG_LN],
489 [AC_MSG_CHECKING(whether ln works)
490 AC_CACHE_VAL(acx_cv_prog_LN,
491 [rm -f conftestdata_t
492 echo >conftestdata_f
493 if ln conftestdata_f conftestdata_t 2>/dev/null
494 then
495   acx_cv_prog_LN=ln
496 else
497   acx_cv_prog_LN=no
499 rm -f conftestdata_f conftestdata_t
500 ])dnl
501 if test $acx_cv_prog_LN = no; then
502   LN="ifelse([$1],,cp,[$1])"
503   AC_MSG_RESULT([no, using $LN])
504 else
505   LN="$acx_cv_prog_LN"
506   AC_MSG_RESULT(yes)
508 AC_SUBST(LN)dnl
511 dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE)
512 AC_DEFUN([GCC_TARGET_TOOL],
513 [AC_MSG_CHECKING(where to find the target $1)
514 if test "x${build}" != "x${host}" ; then
515   if expr "x[$]$2" : "x/" > /dev/null; then
516     # We already found the complete path
517     ac_dir=`dirname [$]$2`
518     AC_MSG_RESULT(pre-installed in $ac_dir)
519   else
520     # Canadian cross, just use what we found
521     AC_MSG_RESULT(pre-installed)
522   fi
523 else
524   ifelse([$4],,,
525   [ok=yes
526   case " ${configdirs} " in
527     *" patsubst([$4], [/.*], []) "*) ;;
528     *) ok=no ;;
529   esac
530   ifelse([$5],,, 
531   [case ,${enable_languages}, in
532     *,$5,*) ;;
533     *) ok=no ;;
534   esac])
535   if test $ok = yes; then
536     # An in-tree tool is available and we can use it
537     $2='$$r/$(HOST_SUBDIR)/$4'
538     AC_MSG_RESULT(just compiled)
539   el])if expr "x[$]$2" : "x/" > /dev/null; then
540     # We already found the complete path
541     ac_dir=`dirname [$]$2`
542     AC_MSG_RESULT(pre-installed in $ac_dir)
543   elif test "x$target" = "x$host"; then
544     # We can use an host tool
545     $2='$($3)'
546     AC_MSG_RESULT(host tool)
547   else
548     # We need a cross tool
549     AC_MSG_RESULT(pre-installed)
550   fi
552 AC_SUBST($2)])
555 dnl Locate a program and check that its version is acceptable.
556 dnl ACX_PROG_CHECK_VER(var, name, version-switch,
557 dnl                    version-extract-regexp, version-glob)
558 AC_DEFUN([ACX_CHECK_PROG_VER],[
559   AC_CHECK_PROG([$1], [$2], [$2])
560   if test -n "[$]$1"; then
561     # Found it, now check the version.
562     AC_CACHE_CHECK([for modern $2],
563                    [gcc_cv_prog_$2_modern],
564                    [ac_prog_version=`eval [$]$1 $3 2>&1 |
565                                      sed -n 's/^.*patsubst([[$4]],/,\/).*$/\1/p'`
567                     [case $ac_prog_version in
568                       '')  gcc_cv_prog_$2_modern=no;;
569                       $5)  gcc_cv_prog_$2_modern=yes;;
570                       *)   gcc_cv_prog_$2_modern=no;;
571                     esac]
572                    ])
573   else
574     gcc_cv_prog_$2_modern=no
575   fi
576   if test $gcc_cv_prog_$2_modern = no; then
577     $1="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing $2"
578   fi
581 dnl Support the --with-pkgversion configure option.
582 dnl ACX_PKGVERSION(default-pkgversion)
583 AC_DEFUN([ACX_PKGVERSION],[
584   AC_ARG_WITH(pkgversion,
585     AS_HELP_STRING([--with-pkgversion=PKG],
586                    [Use PKG in the version string in place of "$1"]),
587     [case "$withval" in
588       yes) AC_MSG_ERROR([package version not specified]) ;;
589       no)  PKGVERSION= ;;
590       *)   PKGVERSION="($withval) " ;;
591      esac],
592     PKGVERSION="($1) "
593   )
594   AC_SUBST(PKGVERSION)
597 dnl Support the --with-bugurl configure option.
598 dnl ACX_BUGURL(default-bugurl)
599 AC_DEFUN([ACX_BUGURL],[
600   AC_ARG_WITH(bugurl,
601     AS_HELP_STRING([--with-bugurl=URL],
602                    [Direct users to URL to report a bug]),
603     [case "$withval" in
604       yes) AC_MSG_ERROR([bug URL not specified]) ;;
605       no)  BUGURL=
606            ;;
607       *)   BUGURL="$withval"
608            ;;
609      esac],
610      BUGURL="$1"
611   )
612   case ${BUGURL} in
613   "")
614     REPORT_BUGS_TO=
615     REPORT_BUGS_TEXI=
616     ;;
617   *)
618     REPORT_BUGS_TO="<$BUGURL>"
619     REPORT_BUGS_TEXI=@uref{`echo "$BUGURL" | sed 's/@/@@/g'`}
620     ;;
621   esac;
622   AC_SUBST(REPORT_BUGS_TO)
623   AC_SUBST(REPORT_BUGS_TEXI)
626 dnl ####
627 dnl # ACX_CHECK_CYGWIN_CAT_WORKS
628 dnl # On Cygwin hosts, check that the cat command ignores 
629 dnl # carriage returns as otherwise builds will not work.
630 dnl # See binutils PR 4334 for more details.
631 AC_DEFUN([ACX_CHECK_CYGWIN_CAT_WORKS],[
632 AC_MSG_CHECKING([to see if cat works as expected])
633 echo a >cygwin-cat-check
634 if test `cat cygwin-cat-check` = a ; then
635   rm cygwin-cat-check
636   AC_MSG_RESULT(yes)
637 else
638   rm cygwin-cat-check
639   AC_MSG_RESULT(no)
640   AC_MSG_ERROR([The cat command does not ignore carriage return characters.
641   Please either mount the build directory in binary mode or run the following
642   commands before running any configure script:
643 set -o igncr
644 export SHELLOPTS 
645   ])