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 & gnatmake programs, as well as a compiler driver
 360 # that understands Ada.  We use the user's CC setting, already found, and
 361 # 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 -c +17 $$f1 > tmp-foo1; tail -c +17 $$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 ])