OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [config/] [acx.m4] - Diff between revs 827 and 840

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 827 Rev 840
# Autoconf M4 include file defining utility macros for complex Canadian
# Autoconf M4 include file defining utility macros for complex Canadian
# cross builds.
# cross builds.
 
 
dnl ####
dnl ####
dnl # _GCC_TOPLEV_NONCANONICAL_BUILD
dnl # _GCC_TOPLEV_NONCANONICAL_BUILD
dnl # $build_alias or canonical $build if blank.
dnl # $build_alias or canonical $build if blank.
dnl # Used when we would use $build_alias, but empty is not OK.
dnl # Used when we would use $build_alias, but empty is not OK.
AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_BUILD],
AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_BUILD],
[AC_REQUIRE([AC_CANONICAL_BUILD]) []dnl
[AC_REQUIRE([AC_CANONICAL_BUILD]) []dnl
case ${build_alias} in
case ${build_alias} in
  "") build_noncanonical=${build} ;;
  "") build_noncanonical=${build} ;;
  *) build_noncanonical=${build_alias} ;;
  *) build_noncanonical=${build_alias} ;;
esac
esac
]) []dnl # _GCC_TOPLEV_NONCANONICAL_BUILD
]) []dnl # _GCC_TOPLEV_NONCANONICAL_BUILD
 
 
dnl ####
dnl ####
dnl # _GCC_TOPLEV_NONCANONICAL_HOST
dnl # _GCC_TOPLEV_NONCANONICAL_HOST
dnl # $host_alias, or $build_noncanonical if blank.
dnl # $host_alias, or $build_noncanonical if blank.
dnl # Used when we would use $host_alias, but empty is not OK.
dnl # Used when we would use $host_alias, but empty is not OK.
AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_HOST],
AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_HOST],
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl
case ${host_alias} in
case ${host_alias} in
  "") host_noncanonical=${build_noncanonical} ;;
  "") host_noncanonical=${build_noncanonical} ;;
  *) host_noncanonical=${host_alias} ;;
  *) host_noncanonical=${host_alias} ;;
esac
esac
]) []dnl # _GCC_TOPLEV_NONCANONICAL_HOST
]) []dnl # _GCC_TOPLEV_NONCANONICAL_HOST
 
 
dnl ####
dnl ####
dnl # _GCC_TOPLEV_NONCANONICAL_TARGET
dnl # _GCC_TOPLEV_NONCANONICAL_TARGET
dnl # $target_alias or $host_noncanonical if blank.
dnl # $target_alias or $host_noncanonical if blank.
dnl # Used when we would use $target_alias, but empty is not OK.
dnl # Used when we would use $target_alias, but empty is not OK.
AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_TARGET],
AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_TARGET],
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_HOST]) []dnl
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_HOST]) []dnl
case ${target_alias} in
case ${target_alias} in
  "") target_noncanonical=${host_noncanonical} ;;
  "") target_noncanonical=${host_noncanonical} ;;
  *) target_noncanonical=${target_alias} ;;
  *) target_noncanonical=${target_alias} ;;
esac
esac
]) []dnl # _GCC_TOPLEV_NONCANONICAL_TARGET
]) []dnl # _GCC_TOPLEV_NONCANONICAL_TARGET
 
 
dnl ####
dnl ####
dnl # ACX_NONCANONICAL_BUILD
dnl # ACX_NONCANONICAL_BUILD
dnl # Like underscored version, but AC_SUBST's.
dnl # Like underscored version, but AC_SUBST's.
AC_DEFUN([ACX_NONCANONICAL_BUILD],
AC_DEFUN([ACX_NONCANONICAL_BUILD],
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl
AC_SUBST(build_noncanonical)
AC_SUBST(build_noncanonical)
]) []dnl # ACX_NONCANONICAL_BUILD
]) []dnl # ACX_NONCANONICAL_BUILD
 
 
dnl ####
dnl ####
dnl # ACX_NONCANONICAL_HOST
dnl # ACX_NONCANONICAL_HOST
dnl # Like underscored version, but AC_SUBST's.
dnl # Like underscored version, but AC_SUBST's.
AC_DEFUN([ACX_NONCANONICAL_HOST],
AC_DEFUN([ACX_NONCANONICAL_HOST],
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_HOST]) []dnl
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_HOST]) []dnl
AC_SUBST(host_noncanonical)
AC_SUBST(host_noncanonical)
]) []dnl # ACX_NONCANONICAL_HOST
]) []dnl # ACX_NONCANONICAL_HOST
 
 
dnl ####
dnl ####
dnl # ACX_NONCANONICAL_TARGET
dnl # ACX_NONCANONICAL_TARGET
dnl # Like underscored version, but AC_SUBST's.
dnl # Like underscored version, but AC_SUBST's.
AC_DEFUN([ACX_NONCANONICAL_TARGET],
AC_DEFUN([ACX_NONCANONICAL_TARGET],
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_TARGET]) []dnl
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_TARGET]) []dnl
AC_SUBST(target_noncanonical)
AC_SUBST(target_noncanonical)
]) []dnl # ACX_NONCANONICAL_TARGET
]) []dnl # ACX_NONCANONICAL_TARGET
 
 
dnl ####
dnl ####
dnl # GCC_TOPLEV_SUBDIRS
dnl # GCC_TOPLEV_SUBDIRS
dnl # GCC & friends build 'build', 'host', and 'target' tools.  These must
dnl # GCC & friends build 'build', 'host', and 'target' tools.  These must
dnl # be separated into three well-known subdirectories of the build directory:
dnl # be separated into three well-known subdirectories of the build directory:
dnl # build_subdir, host_subdir, and target_subdir.  The values are determined
dnl # build_subdir, host_subdir, and target_subdir.  The values are determined
dnl # here so that they can (theoretically) be changed in the future.  They
dnl # here so that they can (theoretically) be changed in the future.  They
dnl # were previously reproduced across many different files.
dnl # were previously reproduced across many different files.
dnl #
dnl #
dnl # This logic really amounts to very little with autoconf 2.13; it will
dnl # This logic really amounts to very little with autoconf 2.13; it will
dnl # amount to a lot more with autoconf 2.5x.
dnl # amount to a lot more with autoconf 2.5x.
AC_DEFUN([GCC_TOPLEV_SUBDIRS],
AC_DEFUN([GCC_TOPLEV_SUBDIRS],
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_TARGET]) []dnl
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_TARGET]) []dnl
AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl
AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl
 
 
# post-stage1 host modules use a different CC_FOR_BUILD so, in order to
# post-stage1 host modules use a different CC_FOR_BUILD so, in order to
# have matching libraries, they should use host libraries: Makefile.tpl
# have matching libraries, they should use host libraries: Makefile.tpl
# arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
# arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
# However, they still use the build modules, because the corresponding
# However, they still use the build modules, because the corresponding
# host modules (e.g. bison) are only built for the host when bootstrap
# host modules (e.g. bison) are only built for the host when bootstrap
# finishes. So:
# finishes. So:
# - build_subdir is where we find build modules, and never changes.
# - build_subdir is where we find build modules, and never changes.
# - build_libsubdir is where we find build libraries, and can be overridden.
# - build_libsubdir is where we find build libraries, and can be overridden.
 
 
# Prefix 'build-' so this never conflicts with target_subdir.
# Prefix 'build-' so this never conflicts with target_subdir.
build_subdir="build-${build_noncanonical}"
build_subdir="build-${build_noncanonical}"
AC_ARG_WITH(build-libsubdir,
AC_ARG_WITH(build-libsubdir,
[  --with-build-libsubdir=[DIR]  Directory where to find libraries for build system],
[  --with-build-libsubdir=[DIR]  Directory where to find libraries for build system],
build_libsubdir="$withval",
build_libsubdir="$withval",
build_libsubdir="$build_subdir")
build_libsubdir="$build_subdir")
# --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
# --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
if ( test $srcdir = . && test -d gcc ) \
if ( test $srcdir = . && test -d gcc ) \
   || test -d $srcdir/../host-${host_noncanonical}; then
   || test -d $srcdir/../host-${host_noncanonical}; then
  host_subdir="host-${host_noncanonical}"
  host_subdir="host-${host_noncanonical}"
else
else
  host_subdir=.
  host_subdir=.
fi
fi
# No prefix.
# No prefix.
target_subdir=${target_noncanonical}
target_subdir=${target_noncanonical}
AC_SUBST([build_libsubdir]) []dnl
AC_SUBST([build_libsubdir]) []dnl
AC_SUBST([build_subdir]) []dnl
AC_SUBST([build_subdir]) []dnl
AC_SUBST([host_subdir]) []dnl
AC_SUBST([host_subdir]) []dnl
AC_SUBST([target_subdir]) []dnl
AC_SUBST([target_subdir]) []dnl
]) []dnl # GCC_TOPLEV_SUBDIRS
]) []dnl # GCC_TOPLEV_SUBDIRS
 
 
 
 
####
####
# _NCN_TOOL_PREFIXES:  Some stuff that oughtta be done in AC_CANONICAL_SYSTEM
# _NCN_TOOL_PREFIXES:  Some stuff that oughtta be done in AC_CANONICAL_SYSTEM
# or AC_INIT.
# or AC_INIT.
# These demand that AC_CANONICAL_SYSTEM be called beforehand.
# These demand that AC_CANONICAL_SYSTEM be called beforehand.
AC_DEFUN([_NCN_TOOL_PREFIXES],
AC_DEFUN([_NCN_TOOL_PREFIXES],
[ncn_tool_prefix=
[ncn_tool_prefix=
test -n "$host_alias" && ncn_tool_prefix=$host_alias-
test -n "$host_alias" && ncn_tool_prefix=$host_alias-
ncn_target_tool_prefix=
ncn_target_tool_prefix=
test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
]) []dnl # _NCN_TOOL_PREFIXES
]) []dnl # _NCN_TOOL_PREFIXES
 
 
####
####
# NCN_STRICT_CHECK_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path])
# NCN_STRICT_CHECK_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path])
# Like plain AC_CHECK_TOOLS, but require prefix if build!=host.
# Like plain AC_CHECK_TOOLS, but require prefix if build!=host.
 
 
AC_DEFUN([NCN_STRICT_CHECK_TOOLS],
AC_DEFUN([NCN_STRICT_CHECK_TOOLS],
[AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl
[AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl
AC_ARG_VAR([$1], [$1 for the host])
AC_ARG_VAR([$1], [$1 for the host])
 
 
if test -n "[$]$1"; then
if test -n "[$]$1"; then
  ac_cv_prog_$1=[$]$1
  ac_cv_prog_$1=[$]$1
elif test -n "$ac_cv_prog_$1"; then
elif test -n "$ac_cv_prog_$1"; then
  $1=$ac_cv_prog_$1
  $1=$ac_cv_prog_$1
fi
fi
 
 
if test -n "$ac_cv_prog_$1"; then
if test -n "$ac_cv_prog_$1"; then
  for ncn_progname in $2; do
  for ncn_progname in $2; do
    AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
    AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
  done
  done
fi
fi
 
 
for ncn_progname in $2; do
for ncn_progname in $2; do
  if test -n "$ncn_tool_prefix"; then
  if test -n "$ncn_tool_prefix"; then
    AC_CHECK_PROG([$1], [${ncn_tool_prefix}${ncn_progname}],
    AC_CHECK_PROG([$1], [${ncn_tool_prefix}${ncn_progname}],
                  [${ncn_tool_prefix}${ncn_progname}], , [$4])
                  [${ncn_tool_prefix}${ncn_progname}], , [$4])
  fi
  fi
  if test -z "$ac_cv_prog_$1" && test $build = $host ; then
  if test -z "$ac_cv_prog_$1" && test $build = $host ; then
    AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
    AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
  fi
  fi
  test -n "$ac_cv_prog_$1" && break
  test -n "$ac_cv_prog_$1" && break
done
done
 
 
if test -z "$ac_cv_prog_$1" ; then
if test -z "$ac_cv_prog_$1" ; then
  ifelse([$3],[], [set dummy $2
  ifelse([$3],[], [set dummy $2
  if test $build = $host ; then
  if test $build = $host ; then
    $1="[$]2"
    $1="[$]2"
  else
  else
    $1="${ncn_tool_prefix}[$]2"
    $1="${ncn_tool_prefix}[$]2"
  fi], [$1="$3"])
  fi], [$1="$3"])
fi
fi
]) []dnl # NCN_STRICT_CHECK_TOOLS
]) []dnl # NCN_STRICT_CHECK_TOOLS
 
 
####
####
# NCN_STRICT_CHECK_TARGET_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path])
# NCN_STRICT_CHECK_TARGET_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path])
# Like CVS Autoconf AC_CHECK_TARGET_TOOLS, but require prefix if build!=target.
# Like CVS Autoconf AC_CHECK_TARGET_TOOLS, but require prefix if build!=target.
 
 
AC_DEFUN([NCN_STRICT_CHECK_TARGET_TOOLS],
AC_DEFUN([NCN_STRICT_CHECK_TARGET_TOOLS],
[AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl
[AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl
AC_ARG_VAR([$1], patsubst([$1], [_FOR_TARGET$], [])[ for the target])
AC_ARG_VAR([$1], patsubst([$1], [_FOR_TARGET$], [])[ for the target])
 
 
if test -n "[$]$1"; then
if test -n "[$]$1"; then
  ac_cv_prog_$1=[$]$1
  ac_cv_prog_$1=[$]$1
elif test -n "$ac_cv_prog_$1"; then
elif test -n "$ac_cv_prog_$1"; then
  $1=$ac_cv_prog_$1
  $1=$ac_cv_prog_$1
fi
fi
 
 
if test -n "$ac_cv_prog_$1"; then
if test -n "$ac_cv_prog_$1"; then
  for ncn_progname in $2; do
  for ncn_progname in $2; do
    AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
    AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
  done
  done
fi
fi
 
 
if test -z "$ac_cv_prog_$1" && test -n "$with_build_time_tools"; then
if test -z "$ac_cv_prog_$1" && test -n "$with_build_time_tools"; then
  for ncn_progname in $2; do
  for ncn_progname in $2; do
    AC_MSG_CHECKING([for ${ncn_progname} in $with_build_time_tools])
    AC_MSG_CHECKING([for ${ncn_progname} in $with_build_time_tools])
    if test -x $with_build_time_tools/${ncn_progname}; then
    if test -x $with_build_time_tools/${ncn_progname}; then
      ac_cv_prog_$1=$with_build_time_tools/${ncn_progname}
      ac_cv_prog_$1=$with_build_time_tools/${ncn_progname}
      AC_MSG_RESULT(yes)
      AC_MSG_RESULT(yes)
      break
      break
    else
    else
      AC_MSG_RESULT(no)
      AC_MSG_RESULT(no)
    fi
    fi
  done
  done
fi
fi
 
 
if test -z "$ac_cv_prog_$1"; then
if test -z "$ac_cv_prog_$1"; then
  for ncn_progname in $2; do
  for ncn_progname in $2; do
    if test -n "$ncn_target_tool_prefix"; then
    if test -n "$ncn_target_tool_prefix"; then
      AC_CHECK_PROG([$1], [${ncn_target_tool_prefix}${ncn_progname}],
      AC_CHECK_PROG([$1], [${ncn_target_tool_prefix}${ncn_progname}],
                    [${ncn_target_tool_prefix}${ncn_progname}], , [$4])
                    [${ncn_target_tool_prefix}${ncn_progname}], , [$4])
    fi
    fi
    if test -z "$ac_cv_prog_$1" && test $build = $target ; then
    if test -z "$ac_cv_prog_$1" && test $build = $target ; then
      AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
      AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
    fi
    fi
    test -n "$ac_cv_prog_$1" && break
    test -n "$ac_cv_prog_$1" && break
  done
  done
fi
fi
 
 
if test -z "$ac_cv_prog_$1" ; then
if test -z "$ac_cv_prog_$1" ; then
  ifelse([$3],[], [set dummy $2
  ifelse([$3],[], [set dummy $2
  if test $build = $target ; then
  if test $build = $target ; then
    $1="[$]2"
    $1="[$]2"
  else
  else
    $1="${ncn_target_tool_prefix}[$]2"
    $1="${ncn_target_tool_prefix}[$]2"
  fi], [$1="$3"])
  fi], [$1="$3"])
else
else
  $1="$ac_cv_prog_$1"
  $1="$ac_cv_prog_$1"
fi
fi
]) []dnl # NCN_STRICT_CHECK_TARGET_TOOLS
]) []dnl # NCN_STRICT_CHECK_TARGET_TOOLS
 
 
 
 
# Backported from Autoconf 2.5x; can go away when and if
# Backported from Autoconf 2.5x; can go away when and if
# we switch.  Put the OS path separator in $PATH_SEPARATOR.
# we switch.  Put the OS path separator in $PATH_SEPARATOR.
AC_DEFUN([ACX_PATH_SEP], [
AC_DEFUN([ACX_PATH_SEP], [
# The user is always right.
# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
if test "${PATH_SEPARATOR+set}" != set; then
  echo "#! /bin/sh" >conf$$.sh
  echo "#! /bin/sh" >conf$$.sh
  echo  "exit 0"   >>conf$$.sh
  echo  "exit 0"   >>conf$$.sh
  chmod +x conf$$.sh
  chmod +x conf$$.sh
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
    PATH_SEPARATOR=';'
    PATH_SEPARATOR=';'
  else
  else
    PATH_SEPARATOR=:
    PATH_SEPARATOR=:
  fi
  fi
  rm -f conf$$.sh
  rm -f conf$$.sh
fi
fi
])
])
 
 
 
 
AC_DEFUN([ACX_TOOL_DIRS], [
AC_DEFUN([ACX_TOOL_DIRS], [
AC_REQUIRE([ACX_PATH_SEP])
AC_REQUIRE([ACX_PATH_SEP])
if test "x$exec_prefix" = xNONE; then
if test "x$exec_prefix" = xNONE; then
        if test "x$prefix" = xNONE; then
        if test "x$prefix" = xNONE; then
                gcc_cv_tool_prefix=$ac_default_prefix
                gcc_cv_tool_prefix=$ac_default_prefix
        else
        else
                gcc_cv_tool_prefix=$prefix
                gcc_cv_tool_prefix=$prefix
        fi
        fi
else
else
        gcc_cv_tool_prefix=$exec_prefix
        gcc_cv_tool_prefix=$exec_prefix
fi
fi
 
 
# If there is no compiler in the tree, use the PATH only.  In any
# If there is no compiler in the tree, use the PATH only.  In any
# case, if there is no compiler in the tree nobody should use
# case, if there is no compiler in the tree nobody should use
# AS_FOR_TARGET and LD_FOR_TARGET.
# AS_FOR_TARGET and LD_FOR_TARGET.
if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
    gcc_version=`cat $srcdir/gcc/BASE-VER`
    gcc_version=`cat $srcdir/gcc/BASE-VER`
    gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
    gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
else
else
    gcc_cv_tool_dirs=
    gcc_cv_tool_dirs=
fi
fi
 
 
if test x$build = x$target && test -n "$md_exec_prefix"; then
if test x$build = x$target && test -n "$md_exec_prefix"; then
        gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
        gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
fi
fi
 
 
]) []dnl # ACX_TOOL_DIRS
]) []dnl # ACX_TOOL_DIRS
 
 
# ACX_HAVE_GCC_FOR_TARGET
# ACX_HAVE_GCC_FOR_TARGET
# Check if the variable GCC_FOR_TARGET really points to a GCC binary.
# Check if the variable GCC_FOR_TARGET really points to a GCC binary.
AC_DEFUN([ACX_HAVE_GCC_FOR_TARGET], [
AC_DEFUN([ACX_HAVE_GCC_FOR_TARGET], [
cat > conftest.c << \EOF
cat > conftest.c << \EOF
#ifdef __GNUC__
#ifdef __GNUC__
  gcc_yay;
  gcc_yay;
#endif
#endif
EOF
EOF
if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
  have_gcc_for_target=yes
  have_gcc_for_target=yes
else
else
  GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
  GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
  have_gcc_for_target=no
  have_gcc_for_target=no
fi
fi
rm conftest.c
rm conftest.c
])
])
 
 
# ACX_CHECK_INSTALLED_TARGET_TOOL(VAR, PROG)
# ACX_CHECK_INSTALLED_TARGET_TOOL(VAR, PROG)
# Searching for installed target binutils.  We need to take extra care,
# Searching for installed target binutils.  We need to take extra care,
# else we may find the wrong assembler, linker, etc., and lose.
# else we may find the wrong assembler, linker, etc., and lose.
#
#
# First try --with-build-time-tools, if specified.
# First try --with-build-time-tools, if specified.
#
#
# For build != host, we ask the installed GCC for the name of the tool it
# For build != host, we ask the installed GCC for the name of the tool it
# uses, and accept it if it is an absolute path.  This is because the
# uses, and accept it if it is an absolute path.  This is because the
# only good choice for a compiler is the same GCC version that is being
# only good choice for a compiler is the same GCC version that is being
# installed (or we couldn't make target libraries), and we assume that
# installed (or we couldn't make target libraries), and we assume that
# on the host system we'll have not only the same GCC version, but also
# on the host system we'll have not only the same GCC version, but also
# the same binutils version.
# the same binutils version.
#
#
# For build == host, search the same directories that the installed
# For build == host, search the same directories that the installed
# compiler will search.  We used to do this for the assembler, linker,
# compiler will search.  We used to do this for the assembler, linker,
# and nm only; for simplicity of configuration, however, we extend this
# and nm only; for simplicity of configuration, however, we extend this
# criterion to tools (such as ar and ranlib) that are never invoked by
# criterion to tools (such as ar and ranlib) that are never invoked by
# the compiler, to avoid mismatches.
# the compiler, to avoid mismatches.
#
#
# Also note we have to check MD_EXEC_PREFIX before checking the user's path
# Also note we have to check MD_EXEC_PREFIX before checking the user's path
# if build == target.  This makes the most sense only when bootstrapping,
# if build == target.  This makes the most sense only when bootstrapping,
# but we also do so when build != host.  In this case, we hope that the
# but we also do so when build != host.  In this case, we hope that the
# build and host systems will have similar contents of MD_EXEC_PREFIX.
# build and host systems will have similar contents of MD_EXEC_PREFIX.
#
#
# If we do not find a suitable binary, then try the user's path.
# If we do not find a suitable binary, then try the user's path.
 
 
AC_DEFUN([ACX_CHECK_INSTALLED_TARGET_TOOL], [
AC_DEFUN([ACX_CHECK_INSTALLED_TARGET_TOOL], [
AC_REQUIRE([ACX_TOOL_DIRS])
AC_REQUIRE([ACX_TOOL_DIRS])
AC_REQUIRE([ACX_HAVE_GCC_FOR_TARGET])
AC_REQUIRE([ACX_HAVE_GCC_FOR_TARGET])
if test -z "$ac_cv_path_$1" ; then
if test -z "$ac_cv_path_$1" ; then
  if test -n "$with_build_time_tools"; then
  if test -n "$with_build_time_tools"; then
    AC_MSG_CHECKING([for $2 in $with_build_time_tools])
    AC_MSG_CHECKING([for $2 in $with_build_time_tools])
    if test -x $with_build_time_tools/$2; then
    if test -x $with_build_time_tools/$2; then
      $1=`cd $with_build_time_tools && pwd`/$2
      $1=`cd $with_build_time_tools && pwd`/$2
      ac_cv_path_$1=[$]$1
      ac_cv_path_$1=[$]$1
      AC_MSG_RESULT([$ac_cv_path_$1])
      AC_MSG_RESULT([$ac_cv_path_$1])
    else
    else
      AC_MSG_RESULT(no)
      AC_MSG_RESULT(no)
    fi
    fi
  elif test $build != $host && test $have_gcc_for_target = yes; then
  elif test $build != $host && test $have_gcc_for_target = yes; then
    $1=`$GCC_FOR_TARGET --print-prog-name=$2`
    $1=`$GCC_FOR_TARGET --print-prog-name=$2`
    test [$]$1 = $2 && $1=
    test [$]$1 = $2 && $1=
    test -n "[$]$1" && ac_cv_path_$1=[$]$1
    test -n "[$]$1" && ac_cv_path_$1=[$]$1
  fi
  fi
fi
fi
if test -z "$ac_cv_path_$1" && test -n "$gcc_cv_tool_dirs"; then
if test -z "$ac_cv_path_$1" && test -n "$gcc_cv_tool_dirs"; then
  AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs])
  AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs])
fi
fi
if test -z "$ac_cv_path_$1" ; then
if test -z "$ac_cv_path_$1" ; then
  NCN_STRICT_CHECK_TARGET_TOOLS([$1], [$2])
  NCN_STRICT_CHECK_TARGET_TOOLS([$1], [$2])
else
else
  $1=$ac_cv_path_$1
  $1=$ac_cv_path_$1
fi
fi
]) []dnl # ACX_CHECK_INSTALLED_TARGET_TOOL
]) []dnl # ACX_CHECK_INSTALLED_TARGET_TOOL
 
 
###
###
# AC_PROG_CPP_WERROR
# AC_PROG_CPP_WERROR
# Used for autoconf 2.5x to force AC_PREPROC_IFELSE to reject code which
# Used for autoconf 2.5x to force AC_PREPROC_IFELSE to reject code which
# triggers warnings from the preprocessor.  Will be in autoconf 2.58.
# triggers warnings from the preprocessor.  Will be in autoconf 2.58.
# For now, using this also overrides header checks to use only the
# For now, using this also overrides header checks to use only the
# preprocessor (matches 2.13 behavior; matching 2.58's behavior is a
# preprocessor (matches 2.13 behavior; matching 2.58's behavior is a
# bit harder from here).
# bit harder from here).
# Eventually autoconf will default to checking headers with the compiler
# Eventually autoconf will default to checking headers with the compiler
# instead, and we'll have to do this differently.
# instead, and we'll have to do this differently.
 
 
AC_DEFUN([AC_PROG_CPP_WERROR],
AC_DEFUN([AC_PROG_CPP_WERROR],
[AC_REQUIRE([AC_PROG_CPP])dnl
[AC_REQUIRE([AC_PROG_CPP])dnl
m4_define([AC_CHECK_HEADER],m4_defn([_AC_CHECK_HEADER_OLD]))
m4_define([AC_CHECK_HEADER],m4_defn([_AC_CHECK_HEADER_OLD]))
ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR
ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR
 
 
# Test for GNAT.
# Test for GNAT.
# We require the gnatbind program, and a compiler driver that
# We require the gnatbind program, and a compiler driver that
# understands Ada.  We use the user's CC setting, already found,
# understands Ada.  We use the user's CC setting, already found,
# and possibly add $1 to the command-line parameters.
# and possibly add $1 to the command-line parameters.
#
#
# Sets the shell variable have_gnat to yes or no as appropriate, and
# Sets the shell variable have_gnat to yes or no as appropriate, and
# substitutes GNATBIND and GNATMAKE.
# substitutes GNATBIND and GNATMAKE.
AC_DEFUN([ACX_PROG_GNAT],
AC_DEFUN([ACX_PROG_GNAT],
[AC_REQUIRE([AC_CHECK_TOOL_PREFIX])
[AC_REQUIRE([AC_CHECK_TOOL_PREFIX])
AC_REQUIRE([AC_PROG_CC])
AC_REQUIRE([AC_PROG_CC])
AC_CHECK_TOOL(GNATBIND, gnatbind, no)
AC_CHECK_TOOL(GNATBIND, gnatbind, no)
AC_CHECK_TOOL(GNATMAKE, gnatmake, no)
AC_CHECK_TOOL(GNATMAKE, gnatmake, no)
AC_CACHE_CHECK([whether compiler driver understands Ada],
AC_CACHE_CHECK([whether compiler driver understands Ada],
                 acx_cv_cc_gcc_supports_ada,
                 acx_cv_cc_gcc_supports_ada,
[cat >conftest.adb <<EOF
[cat >conftest.adb <<EOF
procedure conftest is begin null; end conftest;
procedure conftest is begin null; end conftest;
EOF
EOF
acx_cv_cc_gcc_supports_ada=no
acx_cv_cc_gcc_supports_ada=no
# There is a bug in old released versions of GCC which causes the
# There is a bug in old released versions of GCC which causes the
# driver to exit successfully when the appropriate language module
# driver to exit successfully when the appropriate language module
# has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
# has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
# Therefore we must check for the error message as well as an
# Therefore we must check for the error message as well as an
# unsuccessful exit.
# unsuccessful exit.
# Other compilers, like HP Tru64 UNIX cc, exit successfully when
# Other compilers, like HP Tru64 UNIX cc, exit successfully when
# given a .adb file, but produce no object file.  So we must check
# given a .adb file, but produce no object file.  So we must check
# if an object file was really produced to guard against this.
# if an object file was really produced to guard against this.
errors=`(${CC} $1[]m4_ifval([$1], [ ])-c conftest.adb) 2>&1 || echo failure`
errors=`(${CC} $1[]m4_ifval([$1], [ ])-c conftest.adb) 2>&1 || echo failure`
if test x"$errors" = x && test -f conftest.$ac_objext; then
if test x"$errors" = x && test -f conftest.$ac_objext; then
  acx_cv_cc_gcc_supports_ada=yes
  acx_cv_cc_gcc_supports_ada=yes
fi
fi
rm -f conftest.*])
rm -f conftest.*])
 
 
if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
  have_gnat=yes
  have_gnat=yes
else
else
  have_gnat=no
  have_gnat=no
fi
fi
])
])
 
 
dnl 'make compare' can be significantly faster, if cmp itself can
dnl 'make compare' can be significantly faster, if cmp itself can
dnl skip bytes instead of using tail.  The test being performed is
dnl skip bytes instead of using tail.  The test being performed is
dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
dnl but we need to sink errors and handle broken shells.  We also test
dnl but we need to sink errors and handle broken shells.  We also test
dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
dnl accepted by cmp on some systems.
dnl accepted by cmp on some systems.
AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL],
AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL],
[AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip,
[AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip,
[ echo abfoo >t1
[ echo abfoo >t1
  echo cdfoo >t2
  echo cdfoo >t2
  gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
  gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
  if cmp t1 t2 2 2 > /dev/null 2>&1; then
  if cmp t1 t2 2 2 > /dev/null 2>&1; then
    if cmp t1 t2 1 1 > /dev/null 2>&1; then
    if cmp t1 t2 1 1 > /dev/null 2>&1; then
      :
      :
    else
    else
      gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
      gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
    fi
    fi
  fi
  fi
  if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
  if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
    if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
    if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
      :
      :
    else
    else
      gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
      gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
    fi
    fi
  fi
  fi
  rm t1 t2
  rm t1 t2
])
])
do_compare="$gcc_cv_prog_cmp_skip"
do_compare="$gcc_cv_prog_cmp_skip"
AC_SUBST(do_compare)
AC_SUBST(do_compare)
])
])
 
 
dnl See whether we can include both string.h and strings.h.
dnl See whether we can include both string.h and strings.h.
AC_DEFUN([ACX_HEADER_STRING],
AC_DEFUN([ACX_HEADER_STRING],
[AC_CACHE_CHECK([whether string.h and strings.h may both be included],
[AC_CACHE_CHECK([whether string.h and strings.h may both be included],
  gcc_cv_header_string,
  gcc_cv_header_string,
[AC_TRY_COMPILE([#include <string.h>
[AC_TRY_COMPILE([#include <string.h>
#include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)])
#include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)])
if test $gcc_cv_header_string = yes; then
if test $gcc_cv_header_string = yes; then
  AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.])
  AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.])
fi
fi
])
])
 
 
dnl See if stdbool.h properly defines bool and true/false.
dnl See if stdbool.h properly defines bool and true/false.
dnl Check whether _Bool is built-in.
dnl Check whether _Bool is built-in.
AC_DEFUN([ACX_HEADER_STDBOOL],
AC_DEFUN([ACX_HEADER_STDBOOL],
[AC_CACHE_CHECK([for working stdbool.h],
[AC_CACHE_CHECK([for working stdbool.h],
  ac_cv_header_stdbool_h,
  ac_cv_header_stdbool_h,
[AC_TRY_COMPILE([#include <stdbool.h>],
[AC_TRY_COMPILE([#include <stdbool.h>],
[bool foo = false;],
[bool foo = false;],
ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)])
ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)])
if test $ac_cv_header_stdbool_h = yes; then
if test $ac_cv_header_stdbool_h = yes; then
  AC_DEFINE(HAVE_STDBOOL_H, 1,
  AC_DEFINE(HAVE_STDBOOL_H, 1,
  [Define if you have a working <stdbool.h> header file.])
  [Define if you have a working <stdbool.h> header file.])
fi
fi
AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool,
AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool,
[AC_TRY_COMPILE(,
[AC_TRY_COMPILE(,
[_Bool foo;],
[_Bool foo;],
gcc_cv_c__bool=yes, gcc_cv_c__bool=no)
gcc_cv_c__bool=yes, gcc_cv_c__bool=no)
])
])
if test $gcc_cv_c__bool = yes; then
if test $gcc_cv_c__bool = yes; then
  AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.])
  AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.])
fi
fi
])
])
 
 
dnl See if hard links work and if not, try to substitute $1 or simple copy.
dnl See if hard links work and if not, try to substitute $1 or simple copy.
AC_DEFUN([ACX_PROG_LN],
AC_DEFUN([ACX_PROG_LN],
[AC_MSG_CHECKING(whether ln works)
[AC_MSG_CHECKING(whether ln works)
AC_CACHE_VAL(acx_cv_prog_LN,
AC_CACHE_VAL(acx_cv_prog_LN,
[rm -f conftestdata_t
[rm -f conftestdata_t
echo >conftestdata_f
echo >conftestdata_f
if ln conftestdata_f conftestdata_t 2>/dev/null
if ln conftestdata_f conftestdata_t 2>/dev/null
then
then
  acx_cv_prog_LN=ln
  acx_cv_prog_LN=ln
else
else
  acx_cv_prog_LN=no
  acx_cv_prog_LN=no
fi
fi
rm -f conftestdata_f conftestdata_t
rm -f conftestdata_f conftestdata_t
])dnl
])dnl
if test $acx_cv_prog_LN = no; then
if test $acx_cv_prog_LN = no; then
  LN="ifelse([$1],,cp,[$1])"
  LN="ifelse([$1],,cp,[$1])"
  AC_MSG_RESULT([no, using $LN])
  AC_MSG_RESULT([no, using $LN])
else
else
  LN="$acx_cv_prog_LN"
  LN="$acx_cv_prog_LN"
  AC_MSG_RESULT(yes)
  AC_MSG_RESULT(yes)
fi
fi
AC_SUBST(LN)dnl
AC_SUBST(LN)dnl
])
])
 
 
dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE)
dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE)
AC_DEFUN([GCC_TARGET_TOOL],
AC_DEFUN([GCC_TARGET_TOOL],
[AC_MSG_CHECKING(where to find the target $1)
[AC_MSG_CHECKING(where to find the target $1)
if test "x${build}" != "x${host}" ; then
if test "x${build}" != "x${host}" ; then
  if expr "x[$]$2" : "x/" > /dev/null; then
  if expr "x[$]$2" : "x/" > /dev/null; then
    # We already found the complete path
    # We already found the complete path
    ac_dir=`dirname [$]$2`
    ac_dir=`dirname [$]$2`
    AC_MSG_RESULT(pre-installed in $ac_dir)
    AC_MSG_RESULT(pre-installed in $ac_dir)
  else
  else
    # Canadian cross, just use what we found
    # Canadian cross, just use what we found
    AC_MSG_RESULT(pre-installed)
    AC_MSG_RESULT(pre-installed)
  fi
  fi
else
else
  ifelse([$4],,,
  ifelse([$4],,,
  [ok=yes
  [ok=yes
  case " ${configdirs} " in
  case " ${configdirs} " in
    *" patsubst([$4], [/.*], []) "*) ;;
    *" patsubst([$4], [/.*], []) "*) ;;
    *) ok=no ;;
    *) ok=no ;;
  esac
  esac
  ifelse([$5],,,
  ifelse([$5],,,
  [case ,${enable_languages}, in
  [case ,${enable_languages}, in
    *,$5,*) ;;
    *,$5,*) ;;
    *) ok=no ;;
    *) ok=no ;;
  esac])
  esac])
  if test $ok = yes; then
  if test $ok = yes; then
    # An in-tree tool is available and we can use it
    # An in-tree tool is available and we can use it
    $2='$$r/$(HOST_SUBDIR)/$4'
    $2='$$r/$(HOST_SUBDIR)/$4'
    AC_MSG_RESULT(just compiled)
    AC_MSG_RESULT(just compiled)
  el])if expr "x[$]$2" : "x/" > /dev/null; then
  el])if expr "x[$]$2" : "x/" > /dev/null; then
    # We already found the complete path
    # We already found the complete path
    ac_dir=`dirname [$]$2`
    ac_dir=`dirname [$]$2`
    AC_MSG_RESULT(pre-installed in $ac_dir)
    AC_MSG_RESULT(pre-installed in $ac_dir)
  elif test "x$target" = "x$host"; then
  elif test "x$target" = "x$host"; then
    # We can use an host tool
    # We can use an host tool
    $2='$($3)'
    $2='$($3)'
    AC_MSG_RESULT(host tool)
    AC_MSG_RESULT(host tool)
  else
  else
    # We need a cross tool
    # We need a cross tool
    AC_MSG_RESULT(pre-installed)
    AC_MSG_RESULT(pre-installed)
  fi
  fi
fi
fi
AC_SUBST($2)])
AC_SUBST($2)])
 
 
 
 
dnl Locate a program and check that its version is acceptable.
dnl Locate a program and check that its version is acceptable.
dnl ACX_PROG_CHECK_VER(var, name, version-switch,
dnl ACX_PROG_CHECK_VER(var, name, version-switch,
dnl                    version-extract-regexp, version-glob)
dnl                    version-extract-regexp, version-glob)
AC_DEFUN([ACX_CHECK_PROG_VER],[
AC_DEFUN([ACX_CHECK_PROG_VER],[
  AC_CHECK_PROG([$1], [$2], [$2])
  AC_CHECK_PROG([$1], [$2], [$2])
  if test -n "[$]$1"; then
  if test -n "[$]$1"; then
    # Found it, now check the version.
    # Found it, now check the version.
    AC_CACHE_CHECK([for modern $2],
    AC_CACHE_CHECK([for modern $2],
                   [gcc_cv_prog_$2_modern],
                   [gcc_cv_prog_$2_modern],
                   [ac_prog_version=`eval [$]$1 $3 2>&1 |
                   [ac_prog_version=`eval [$]$1 $3 2>&1 |
                                     sed -n 's/^.*patsubst([[$4]],/,\/).*$/\1/p'`
                                     sed -n 's/^.*patsubst([[$4]],/,\/).*$/\1/p'`
 
 
                    [case $ac_prog_version in
                    [case $ac_prog_version in
                      '')  gcc_cv_prog_$2_modern=no;;
                      '')  gcc_cv_prog_$2_modern=no;;
                      $5)  gcc_cv_prog_$2_modern=yes;;
                      $5)  gcc_cv_prog_$2_modern=yes;;
                      *)   gcc_cv_prog_$2_modern=no;;
                      *)   gcc_cv_prog_$2_modern=no;;
                    esac]
                    esac]
                   ])
                   ])
  else
  else
    gcc_cv_prog_$2_modern=no
    gcc_cv_prog_$2_modern=no
  fi
  fi
  if test $gcc_cv_prog_$2_modern = no; then
  if test $gcc_cv_prog_$2_modern = no; then
    $1="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing $2"
    $1="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing $2"
  fi
  fi
])
])
 
 
dnl Support the --with-pkgversion configure option.
dnl Support the --with-pkgversion configure option.
dnl ACX_PKGVERSION(default-pkgversion)
dnl ACX_PKGVERSION(default-pkgversion)
AC_DEFUN([ACX_PKGVERSION],[
AC_DEFUN([ACX_PKGVERSION],[
  AC_ARG_WITH(pkgversion,
  AC_ARG_WITH(pkgversion,
    AS_HELP_STRING([--with-pkgversion=PKG],
    AS_HELP_STRING([--with-pkgversion=PKG],
                   [Use PKG in the version string in place of "$1"]),
                   [Use PKG in the version string in place of "$1"]),
    [case "$withval" in
    [case "$withval" in
      yes) AC_MSG_ERROR([package version not specified]) ;;
      yes) AC_MSG_ERROR([package version not specified]) ;;
      no)  PKGVERSION= ;;
      no)  PKGVERSION= ;;
      *)   PKGVERSION="($withval) " ;;
      *)   PKGVERSION="($withval) " ;;
     esac],
     esac],
    PKGVERSION="($1) "
    PKGVERSION="($1) "
  )
  )
  AC_SUBST(PKGVERSION)
  AC_SUBST(PKGVERSION)
])
])
 
 
dnl Support the --with-bugurl configure option.
dnl Support the --with-bugurl configure option.
dnl ACX_BUGURL(default-bugurl)
dnl ACX_BUGURL(default-bugurl)
AC_DEFUN([ACX_BUGURL],[
AC_DEFUN([ACX_BUGURL],[
  AC_ARG_WITH(bugurl,
  AC_ARG_WITH(bugurl,
    AS_HELP_STRING([--with-bugurl=URL],
    AS_HELP_STRING([--with-bugurl=URL],
                   [Direct users to URL to report a bug]),
                   [Direct users to URL to report a bug]),
    [case "$withval" in
    [case "$withval" in
      yes) AC_MSG_ERROR([bug URL not specified]) ;;
      yes) AC_MSG_ERROR([bug URL not specified]) ;;
      no)  BUGURL=
      no)  BUGURL=
           ;;
           ;;
      *)   BUGURL="$withval"
      *)   BUGURL="$withval"
           ;;
           ;;
     esac],
     esac],
     BUGURL="$1"
     BUGURL="$1"
  )
  )
  case ${BUGURL} in
  case ${BUGURL} in
  "")
  "")
    REPORT_BUGS_TO=
    REPORT_BUGS_TO=
    REPORT_BUGS_TEXI=
    REPORT_BUGS_TEXI=
    ;;
    ;;
  *)
  *)
    REPORT_BUGS_TO="<$BUGURL>"
    REPORT_BUGS_TO="<$BUGURL>"
    REPORT_BUGS_TEXI=@uref{`echo "$BUGURL" | sed 's/@/@@/g'`}
    REPORT_BUGS_TEXI=@uref{`echo "$BUGURL" | sed 's/@/@@/g'`}
    ;;
    ;;
  esac;
  esac;
  AC_SUBST(REPORT_BUGS_TO)
  AC_SUBST(REPORT_BUGS_TO)
  AC_SUBST(REPORT_BUGS_TEXI)
  AC_SUBST(REPORT_BUGS_TEXI)
])
])
 
 
dnl ####
dnl ####
dnl # ACX_CHECK_CYGWIN_CAT_WORKS
dnl # ACX_CHECK_CYGWIN_CAT_WORKS
dnl # On Cygwin hosts, check that the cat command ignores
dnl # On Cygwin hosts, check that the cat command ignores
dnl # carriage returns as otherwise builds will not work.
dnl # carriage returns as otherwise builds will not work.
dnl # See binutils PR 4334 for more details.
dnl # See binutils PR 4334 for more details.
AC_DEFUN([ACX_CHECK_CYGWIN_CAT_WORKS],[
AC_DEFUN([ACX_CHECK_CYGWIN_CAT_WORKS],[
AC_MSG_CHECKING([to see if cat works as expected])
AC_MSG_CHECKING([to see if cat works as expected])
echo a >cygwin-cat-check
echo a >cygwin-cat-check
if test `cat cygwin-cat-check` == a ; then
if test `cat cygwin-cat-check` == a ; then
  rm cygwin-cat-check
  rm cygwin-cat-check
  AC_MSG_RESULT(yes)
  AC_MSG_RESULT(yes)
else
else
  rm cygwin-cat-check
  rm cygwin-cat-check
  AC_MSG_RESULT(no)
  AC_MSG_RESULT(no)
  AC_MSG_ERROR([The cat command does not ignore carriage return characters.
  AC_MSG_ERROR([The cat command does not ignore carriage return characters.
  Please either mount the build directory in binary mode or run the following
  Please either mount the build directory in binary mode or run the following
  commands before running any configure script:
  commands before running any configure script:
set -o igncr
set -o igncr
export SHELLOPTS
export SHELLOPTS
  ])
  ])
fi
fi
])
])
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.