OSDN Git Service

d186a4ccccd58d1583416c8d0a5bac9b27ca1dd4
[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 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 #
362 # Sets the shell variable have_gnat to yes or no as appropriate, and
363 # substitutes GNATBIND and GNATMAKE.
364 AC_DEFUN([ACX_PROG_GNAT],
365 [AC_REQUIRE([AC_CHECK_TOOL_PREFIX])
366 AC_REQUIRE([AC_PROG_CC])
367 AC_CHECK_TOOL(GNATBIND, gnatbind, no)
368 AC_CHECK_TOOL(GNATMAKE, gnatmake, no)
369 AC_CACHE_CHECK([whether compiler driver understands Ada],
370                  acx_cv_cc_gcc_supports_ada,
371 [cat >conftest.adb <<EOF
372 procedure conftest is begin null; end conftest;
373 EOF
374 acx_cv_cc_gcc_supports_ada=no
375 # There is a bug in old released versions of GCC which causes the
376 # driver to exit successfully when the appropriate language module
377 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
378 # Therefore we must check for the error message as well as an
379 # unsuccessful exit.
380 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
381 # given a .adb file, but produce no object file.  So we must check
382 # if an object file was really produced to guard against this.
383 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
384 if test x"$errors" = x && test -f conftest.$ac_objext; then
385   acx_cv_cc_gcc_supports_ada=yes
386 fi
387 rm -f conftest.*])
388
389 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
390   have_gnat=yes
391 else
392   have_gnat=no
393 fi
394 ])
395
396 dnl 'make compare' can be significantly faster, if cmp itself can
397 dnl skip bytes instead of using tail.  The test being performed is
398 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
399 dnl but we need to sink errors and handle broken shells.  We also test
400 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
401 dnl accepted by cmp on some systems.
402 AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL],
403 [AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip,
404 [ echo abfoo >t1
405   echo cdfoo >t2
406   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
407   if cmp t1 t2 2 2 > /dev/null 2>&1; then
408     if cmp t1 t2 1 1 > /dev/null 2>&1; then
409       :
410     else
411       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
412     fi
413   fi
414   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
415     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
416       :
417     else
418       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
419     fi
420   fi
421   rm t1 t2
422 ])
423 do_compare="$gcc_cv_prog_cmp_skip"
424 AC_SUBST(do_compare)
425 ])
426
427 dnl See whether we can include both string.h and strings.h.
428 AC_DEFUN([ACX_HEADER_STRING],
429 [AC_CACHE_CHECK([whether string.h and strings.h may both be included],
430   gcc_cv_header_string,
431 [AC_TRY_COMPILE([#include <string.h>
432 #include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)])
433 if test $gcc_cv_header_string = yes; then
434   AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.])
435 fi
436 ])
437
438 dnl See if stdbool.h properly defines bool and true/false.
439 dnl Check whether _Bool is built-in.
440 AC_DEFUN([ACX_HEADER_STDBOOL],
441 [AC_CACHE_CHECK([for working stdbool.h],
442   ac_cv_header_stdbool_h,
443 [AC_TRY_COMPILE([#include <stdbool.h>],
444 [bool foo = false;],
445 ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)])
446 if test $ac_cv_header_stdbool_h = yes; then
447   AC_DEFINE(HAVE_STDBOOL_H, 1,
448   [Define if you have a working <stdbool.h> header file.])
449 fi
450 AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool,
451 [AC_TRY_COMPILE(,
452 [_Bool foo;],
453 gcc_cv_c__bool=yes, gcc_cv_c__bool=no)
454 ])
455 if test $gcc_cv_c__bool = yes; then
456   AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.])
457 fi
458 ])
459
460 dnl See if hard links work and if not, try to substitute $1 or simple copy.
461 AC_DEFUN([ACX_PROG_LN],
462 [AC_MSG_CHECKING(whether ln works)
463 AC_CACHE_VAL(acx_cv_prog_LN,
464 [rm -f conftestdata_t
465 echo >conftestdata_f
466 if ln conftestdata_f conftestdata_t 2>/dev/null
467 then
468   acx_cv_prog_LN=ln
469 else
470   acx_cv_prog_LN=no
471 fi
472 rm -f conftestdata_f conftestdata_t
473 ])dnl
474 if test $acx_cv_prog_LN = no; then
475   LN="ifelse([$1],,cp,[$1])"
476   AC_MSG_RESULT([no, using $LN])
477 else
478   LN="$acx_cv_prog_LN"
479   AC_MSG_RESULT(yes)
480 fi
481 AC_SUBST(LN)dnl
482 ])
483
484 dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE)
485 AC_DEFUN([GCC_TARGET_TOOL],
486 [AC_MSG_CHECKING(where to find the target $1)
487 if test "x${build}" != "x${host}" ; then
488   if expr "x[$]$2" : "x/" > /dev/null; then
489     # We already found the complete path
490     ac_dir=`dirname [$]$2`
491     AC_MSG_RESULT(pre-installed in $ac_dir)
492   else
493     # Canadian cross, just use what we found
494     AC_MSG_RESULT(pre-installed)
495   fi
496 else
497   ifelse([$4],,,
498   [ok=yes
499   case " ${configdirs} " in
500     *" patsubst([$4], [/.*], []) "*) ;;
501     *) ok=no ;;
502   esac
503   ifelse([$5],,, 
504   [case ,${enable_languages}, in
505     *,$5,*) ;;
506     *) ok=no ;;
507   esac])
508   if test $ok = yes; then
509     # An in-tree tool is available and we can use it
510     $2='$$r/$(HOST_SUBDIR)/$4'
511     AC_MSG_RESULT(just compiled)
512   el])if expr "x[$]$2" : "x/" > /dev/null; then
513     # We already found the complete path
514     ac_dir=`dirname [$]$2`
515     AC_MSG_RESULT(pre-installed in $ac_dir)
516   elif test "x$target" = "x$host"; then
517     # We can use an host tool
518     $2='$($3)'
519     AC_MSG_RESULT(host tool)
520   else
521     # We need a cross tool
522     AC_MSG_RESULT(pre-installed)
523   fi
524 fi
525 AC_SUBST($2)])
526
527
528 dnl Locate a program and check that its version is acceptable.
529 dnl ACX_PROG_CHECK_VER(var, name, version-switch,
530 dnl                    version-extract-regexp, version-glob)
531 AC_DEFUN([ACX_CHECK_PROG_VER],[
532   AC_CHECK_PROG([$1], [$2], [$2])
533   if test -n "[$]$1"; then
534     # Found it, now check the version.
535     AC_CACHE_CHECK([for modern $2],
536                    [gcc_cv_prog_$2_modern],
537                    [ac_prog_version=`eval [$]$1 $3 2>&1 |
538                                      sed -n 's/^.*patsubst([[$4]],/,\/).*$/\1/p'`
539
540                     [case $ac_prog_version in
541                       '')  gcc_cv_prog_$2_modern=no;;
542                       $5)  gcc_cv_prog_$2_modern=yes;;
543                       *)   gcc_cv_prog_$2_modern=no;;
544                     esac]
545                    ])
546   else
547     gcc_cv_prog_$2_modern=no
548   fi
549   if test $gcc_cv_prog_$2_modern = no; then
550     $1="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing $2"
551   fi
552 ])
553
554 dnl Support the --with-pkgversion configure option.
555 dnl ACX_PKGVERSION(default-pkgversion)
556 AC_DEFUN([ACX_PKGVERSION],[
557   AC_ARG_WITH(pkgversion,
558     AS_HELP_STRING([--with-pkgversion=PKG],
559                    [Use PKG in the version string in place of "$1"]),
560     [case "$withval" in
561       yes) AC_MSG_ERROR([package version not specified]) ;;
562       no)  PKGVERSION= ;;
563       *)   PKGVERSION="($withval) " ;;
564      esac],
565     PKGVERSION="($1) "
566   )
567   AC_SUBST(PKGVERSION)
568 ])
569
570 dnl Support the --with-bugurl configure option.
571 dnl ACX_BUGURL(default-bugurl)
572 AC_DEFUN([ACX_BUGURL],[
573   AC_ARG_WITH(bugurl,
574     AS_HELP_STRING([--with-bugurl=URL],
575                    [Direct users to URL to report a bug]),
576     [case "$withval" in
577       yes) AC_MSG_ERROR([bug URL not specified]) ;;
578       no)  BUGURL=
579            ;;
580       *)   BUGURL="$withval"
581            ;;
582      esac],
583      BUGURL="$1"
584   )
585   case ${BUGURL} in
586   "")
587     REPORT_BUGS_TO=
588     REPORT_BUGS_TEXI=
589     ;;
590   *)
591     REPORT_BUGS_TO="<$BUGURL>"
592     REPORT_BUGS_TEXI=@uref{`echo "$BUGURL" | sed 's/@/@@/g'`}
593     ;;
594   esac;
595   AC_SUBST(REPORT_BUGS_TO)
596   AC_SUBST(REPORT_BUGS_TEXI)
597 ])
598
599 dnl ####
600 dnl # ACX_CHECK_CYGWIN_CAT_WORKS
601 dnl # On Cygwin hosts, check that the cat command ignores 
602 dnl # carriage returns as otherwise builds will not work.
603 dnl # See binutils PR 4334 for more details.
604 AC_DEFUN([ACX_CHECK_CYGWIN_CAT_WORKS],[
605 AC_MSG_CHECKING([to see if cat works as expected])
606 echo a >cygwin-cat-check
607 if test `cat cygwin-cat-check` == a ; then
608   rm cygwin-cat-check
609   AC_MSG_RESULT(yes)
610 else
611   rm cygwin-cat-check
612   AC_MSG_RESULT(no)
613   AC_MSG_ERROR([The cat command does not ignore carriage return characters.
614   Please either mount the build directory in binary mode or run the following
615   commands before running any configure script:
616 set -o igncr
617 export SHELLOPTS 
618   ])
619 fi
620 ])