#! /bin/sh

## DO NOT EDIT - This file generated from ./build-aux/ltmain.in

##               by inline-source v2018-07-24.06

# libtool (GNU libtool) 2.4.6.42-b88ce

# Provide generalized library-building support services.

# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996

# Copyright (C) 1996-2018 Free Software Foundation, Inc.

# This is free software; see the source for copying conditions.  There is NO

# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

# GNU Libtool is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# As a special exception to the GNU General Public License,

# if you distribute this file as part of a program or library that

# is built using GNU Libtool, you may include this file under the

# same distribution terms that you use for the rest of that program.

#

# GNU Libtool is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

PROGRAM=libtool

PACKAGE=libtool

VERSION=2.4.6.42-b88ce

package_revision=2.4.6.42

## ------ ##

## Usage. ##

## ------ ##

# Run './libtool --help' for help with using this script from the

# command line.

## ------------------------------- ##

## User overridable command paths. ##

## ------------------------------- ##

# After configure completes, it has a better idea of some of the

# shell tools we need than the defaults used by the functions shared

# with bootstrap, so set those here where they can still be over-

# ridden by the user, but otherwise take precedence.

: ${AUTOCONF="autoconf"}

: ${AUTOMAKE="automake"}

## -------------------------- ##

## Source external libraries. ##

## -------------------------- ##

# Much of our low-level functionality needs to be sourced from external

# libraries, which are installed to $pkgauxdir.

# Set a version string for this script.

scriptversion=2018-07-24.06; # UTC

# General shell script boiler plate, and helper functions.

# Written by Gary V. Vaughan, 2004

# This is free software.  There is NO warranty; not even for

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

#

# Copyright (C) 2004-2018 Bootstrap Authors

#

# This file is dual licensed under the terms of the MIT license

# <https://opensource.org/license/MIT>, and GPL version 3 or later

# <http://www.gnu.org/licenses/gpl-2.0.html>.  You must apply one of

# these licenses when using or redistributing this software or any of

# the files within it.  See the URLs above, or the file `LICENSE`

# included in the Bootstrap distribution for the full license texts.

# Please report bugs or propose patches to:

# <https://github.com/gnulib-modules/bootstrap/issues>

## ------ ##

## Usage. ##

## ------ ##

# Evaluate this file near the top of your script to gain access to

# the functions and variables defined here:

#

#   . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh

#

# If you need to override any of the default environment variable

# settings, do that before evaluating this file.

## -------------------- ##

## Shell normalisation. ##

## -------------------- ##

# Some shells need a little help to be as Bourne compatible as possible.

# Before doing anything else, make sure all that help has been provided!

DUALCASE=1; export DUALCASE # for MKS sh

if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :

  emulate sh

  NULLCMD=:

  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which

  # is contrary to our usage.  Disable this feature.

  alias -g '${1+"$@"}'='"$@"'

  setopt NO_GLOB_SUBST

else

  case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac

fi

# NLS nuisances: We save the old values in case they are required later.

_G_user_locale=

_G_safe_locale=

for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

do

  eval "if test set = \"\${$_G_var+set}\"; then

          save_$_G_var=\$$_G_var

          $_G_var=C

	  export $_G_var

	  _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\"

	  _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"

	fi"

done

# Make sure IFS has a sensible default

sp=' '

nl='

'

IFS="$sp	$nl"

# There are apparently some retarded systems that use ';' as a PATH separator!

if test "${PATH_SEPARATOR+set}" != set; then

  PATH_SEPARATOR=:

  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {

    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||

      PATH_SEPARATOR=';'

  }

fi

# func_unset VAR

# --------------

# Portably unset VAR.

# In some shells, an 'unset VAR' statement leaves a non-zero return

# status if VAR is already unset, which might be problematic if the

# statement is used at the end of a function (thus poisoning its return

# value) or when 'set -e' is active (causing even a spurious abort of

# the script in this case).

func_unset ()

{

    { eval $1=; (eval unset $1) >/dev/null 2>&1 && eval unset $1 || : ; }

}

# Make sure CDPATH doesn't cause `cd` commands to output the target dir.

func_unset CDPATH

# Make sure ${,E,F}GREP behave sanely.

func_unset GREP_OPTIONS

## ------------------------- ##

## Locate command utilities. ##

## ------------------------- ##

# func_executable_p FILE

# ----------------------

# Check that FILE is an executable regular file.

func_executable_p ()

{

    test -f "$1" && test -x "$1"

}

# func_path_progs PROGS_LIST CHECK_FUNC [PATH]

# --------------------------------------------

# Search for either a program that responds to --version with output

# containing "GNU", or else returned by CHECK_FUNC otherwise, by

# trying all the directories in PATH with each of the elements of

# PROGS_LIST.

#

# CHECK_FUNC should accept the path to a candidate program, and

# set $func_check_prog_result if it truncates its output less than

# $_G_path_prog_max characters.

func_path_progs ()

{

    _G_progs_list=$1

    _G_check_func=$2

    _G_PATH=${3-"$PATH"}

    _G_path_prog_max=0

    _G_path_prog_found=false

    _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:}

    for _G_dir in $_G_PATH; do

      IFS=$_G_save_IFS

      test -z "$_G_dir" && _G_dir=.

      for _G_prog_name in $_G_progs_list; do

        for _exeext in '' .EXE; do

          _G_path_prog=$_G_dir/$_G_prog_name$_exeext

          func_executable_p "$_G_path_prog" || continue

          case `"$_G_path_prog" --version 2>&1` in

            *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;;

            *)     $_G_check_func $_G_path_prog

		   func_path_progs_result=$func_check_prog_result

		   ;;

          esac

          $_G_path_prog_found && break 3

        done

      done

    done

    IFS=$_G_save_IFS

    test -z "$func_path_progs_result" && {

      echo "no acceptable sed could be found in \$PATH" >&2

      exit 1

    }

}

# We want to be able to use the functions in this file before configure

# has figured out where the best binaries are kept, which means we have

# to search for them ourselves - except when the results are already set

# where we skip the searches.

# Unless the user overrides by setting SED, search the path for either GNU

# sed, or the sed that truncates its output the least.

test -z "$SED" && {

  _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/

  for _G_i in 1 2 3 4 5 6 7; do

    _G_sed_script=$_G_sed_script$nl$_G_sed_script

  done

  echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed

  _G_sed_script=

  func_check_prog_sed ()

  {

    _G_path_prog=$1

    _G_count=0

    printf 0123456789 >conftest.in

    while :

    do

      cat conftest.in conftest.in >conftest.tmp

      mv conftest.tmp conftest.in

      cp conftest.in conftest.nl

      echo '' >> conftest.nl

      "$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break

      diff conftest.out conftest.nl >/dev/null 2>&1 || break

      _G_count=`expr $_G_count + 1`

      if test "$_G_count" -gt "$_G_path_prog_max"; then

        # Best one so far, save it but keep looking for a better one

        func_check_prog_result=$_G_path_prog

        _G_path_prog_max=$_G_count

      fi

      # 10*(2^10) chars as input seems more than enough

      test 10 -lt "$_G_count" && break

    done

    rm -f conftest.in conftest.tmp conftest.nl conftest.out

  }

  func_path_progs "sed gsed" func_check_prog_sed "$PATH:/usr/xpg4/bin"

  rm -f conftest.sed

  SED=$func_path_progs_result

}

# Unless the user overrides by setting GREP, search the path for either GNU

# grep, or the grep that truncates its output the least.

test -z "$GREP" && {

  func_check_prog_grep ()

  {

    _G_path_prog=$1

    _G_count=0

    _G_path_prog_max=0

    printf 0123456789 >conftest.in

    while :

    do

      cat conftest.in conftest.in >conftest.tmp

      mv conftest.tmp conftest.in

      cp conftest.in conftest.nl

      echo 'GREP' >> conftest.nl

      "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break

      diff conftest.out conftest.nl >/dev/null 2>&1 || break

      _G_count=`expr $_G_count + 1`

      if test "$_G_count" -gt "$_G_path_prog_max"; then

        # Best one so far, save it but keep looking for a better one

        func_check_prog_result=$_G_path_prog

        _G_path_prog_max=$_G_count

      fi

      # 10*(2^10) chars as input seems more than enough

      test 10 -lt "$_G_count" && break

    done

    rm -f conftest.in conftest.tmp conftest.nl conftest.out

  }

  func_path_progs "grep ggrep" func_check_prog_grep "$PATH:/usr/xpg4/bin"

  GREP=$func_path_progs_result

}

## ------------------------------- ##

## User overridable command paths. ##

## ------------------------------- ##

# All uppercase variable names are used for environment variables.  These

# variables can be overridden by the user before calling a script that

# uses them if a suitable command of that name is not already available

# in the command search PATH.

: ${CP="cp -f"}

: ${ECHO="printf %s\n"}

: ${EGREP="$GREP -E"}

: ${FGREP="$GREP -F"}

: ${LN_S="ln -s"}

: ${MAKE="make"}

: ${MKDIR="mkdir"}

: ${MV="mv -f"}

: ${RM="rm -f"}

: ${SHELL="${CONFIG_SHELL-/bin/sh}"}

## -------------------- ##

## Useful sed snippets. ##

## -------------------- ##

sed_dirname='s|/[^/]*$||'

sed_basename='s|^.*/||'

# Sed substitution that helps us do robust quoting.  It backslashifies

# metacharacters that are still active within double-quoted strings.

sed_quote_subst='s|\([`"$\\]\)|\\\1|g'

# Same as above, but do not quote variable references.

sed_double_quote_subst='s/\(["`\\]\)/\\\1/g'

# Sed substitution that turns a string into a regex matching for the

# string literally.

sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g'

# Sed substitution that converts a w32 file name or path

# that contains forward slashes, into one that contains

# (escaped) backslashes.  A very naive implementation.

sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'

# Re-'\' parameter expansions in output of sed_double_quote_subst that

# were '\'-ed in input to the same.  If an odd number of '\' preceded a

# '$' in input to sed_double_quote_subst, that '$' was protected from

# expansion.  Since each input '\' is now two '\'s, look for any number

# of runs of four '\'s followed by two '\'s and then a '$'.  '\' that '$'.

_G_bs='\\'

_G_bs2='\\\\'

_G_bs4='\\\\\\\\'

_G_dollar='\$'

sed_double_backslash="\

  s/$_G_bs4/&\\

/g

  s/^$_G_bs2$_G_dollar/$_G_bs&/

  s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g

  s/\n//g"

## ----------------- ##

## Global variables. ##

## ----------------- ##

# Except for the global variables explicitly listed below, the following

# functions in the '^func_' namespace, and the '^require_' namespace

# variables initialised in the 'Resource management' section, sourcing

# this file will not pollute your global namespace with anything

# else. There's no portable way to scope variables in Bourne shell

# though, so actually running these functions will sometimes place

# results into a variable named after the function, and often use

# temporary variables in the '^_G_' namespace. If you are careful to

# avoid using those namespaces casually in your sourcing script, things

# should continue to work as you expect. And, of course, you can freely

# overwrite any of the functions or variables defined here before

# calling anything to customize them.

EXIT_SUCCESS=0

EXIT_FAILURE=1

EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.

EXIT_SKIP=77	  # $? = 77 is used to indicate a skipped test to automake.

# Allow overriding, eg assuming that you follow the convention of

# putting '$debug_cmd' at the start of all your functions, you can get

# bash to show function call trace with:

#

#    debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name

debug_cmd=${debug_cmd-":"}

exit_cmd=:

# By convention, finish your script with:

#

#    exit $exit_status

#

# so that you can set exit_status to non-zero if you want to indicate

# something went wrong during execution without actually bailing out at

# the point of failure.

exit_status=$EXIT_SUCCESS

# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh

# is ksh but when the shell is invoked as "sh" and the current value of

# the _XPG environment variable is not equal to 1 (one), the special

# positional parameter $0, within a function call, is the name of the

# function.

progpath=$0

# The name of this program.

progname=`$ECHO "$progpath" |$SED "$sed_basename"`

# Make sure we have an absolute progpath for reexecution:

case $progpath in

  [\\/]*|[A-Za-z]:\\*) ;;

  *[\\/]*)

     progdir=`$ECHO "$progpath" |$SED "$sed_dirname"`

     progdir=`cd "$progdir" && pwd`

     progpath=$progdir/$progname

     ;;

  *)

     _G_IFS=$IFS

     IFS=${PATH_SEPARATOR-:}

     for progdir in $PATH; do

       IFS=$_G_IFS

       test -x "$progdir/$progname" && break

     done

     IFS=$_G_IFS

     test -n "$progdir" || progdir=`pwd`

     progpath=$progdir/$progname

     ;;

esac

## ----------------- ##

## Standard options. ##

## ----------------- ##

# The following options affect the operation of the functions defined

# below, and should be set appropriately depending on run-time para-

# meters passed on the command line.

opt_dry_run=false

opt_quiet=false

opt_verbose=false

# Categories 'all' and 'none' are always available.  Append any others

# you will pass as the first argument to func_warning from your own

# code.

warning_categories=

# By default, display warnings according to 'opt_warning_types'.  Set

# 'warning_func'  to ':' to elide all warnings, or func_fatal_error to

# treat the next displayed warning as a fatal error.

warning_func=func_warn_and_continue

# Set to 'all' to display all warnings, 'none' to suppress all

# warnings, or a space delimited list of some subset of

# 'warning_categories' to display only the listed warnings.

opt_warning_types=all

## -------------------- ##

## Resource management. ##

## -------------------- ##

# This section contains definitions for functions that each ensure a

# particular resource (a file, or a non-empty configuration variable for

# example) is available, and if appropriate to extract default values

# from pertinent package files. Call them using their associated

# 'require_*' variable to ensure that they are executed, at most, once.

#

# It's entirely deliberate that calling these functions can set

# variables that don't obey the namespace limitations obeyed by the rest

# of this file, in order that that they be as useful as possible to

# callers.

# require_term_colors

# -------------------

# Allow display of bold text on terminals that support it.

require_term_colors=func_require_term_colors

func_require_term_colors ()

{

    $debug_cmd

    test -t 1 && {

      # COLORTERM and USE_ANSI_COLORS environment variables take

      # precedence, because most terminfo databases neglect to describe

      # whether color sequences are supported.

      test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"}

      if test 1 = "$USE_ANSI_COLORS"; then

        # Standard ANSI escape sequences

        tc_reset='?[0m'

        tc_bold='?[1m';   tc_standout='?[7m'

        tc_red='?[31m';   tc_green='?[32m'

        tc_blue='?[34m';  tc_cyan='?[36m'

      else

        # Otherwise trust the terminfo database after all.

        test -n "`tput sgr0 2>/dev/null`" && {

          tc_reset=`tput sgr0`

          test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold`

          tc_standout=$tc_bold

          test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso`

          test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1`

          test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2`

          test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4`

          test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5`

        }

      fi

    }

    require_term_colors=:

}

## ----------------- ##

## Function library. ##

## ----------------- ##

# This section contains a variety of useful functions to call in your

# scripts. Take note of the portable wrappers for features provided by

# some modern shells, which will fall back to slower equivalents on

# less featureful shells.

# func_append VAR VALUE

# ---------------------

# Append VALUE onto the existing contents of VAR.

  # We should try to minimise forks, especially on Windows where they are

  # unreasonably slow, so skip the feature probes when bash or zsh are

  # being used:

  if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then

    : ${_G_HAVE_ARITH_OP="yes"}

    : ${_G_HAVE_XSI_OPS="yes"}

    # The += operator was introduced in bash 3.1

    case $BASH_VERSION in

      [12].* | 3.0 | 3.0*) ;;

      *)

        : ${_G_HAVE_PLUSEQ_OP="yes"}

        ;;

    esac

  fi

  # _G_HAVE_PLUSEQ_OP

  # Can be empty, in which case the shell is probed, "yes" if += is

  # useable or anything else if it does not work.

  test -z "$_G_HAVE_PLUSEQ_OP" \

    && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \

    && _G_HAVE_PLUSEQ_OP=yes

if test yes = "$_G_HAVE_PLUSEQ_OP"

then

  # This is an XSI compatible shell, allowing a faster implementation...

  eval 'func_append ()

  {

    $debug_cmd

    eval "$1+=\$2"

  }'

else

  # ...otherwise fall back to using expr, which is often a shell builtin.

  func_append ()

  {

    $debug_cmd

    eval "$1=\$$1\$2"

  }

fi

# func_append_quoted VAR VALUE

# ----------------------------

# Quote VALUE and append to the end of shell variable VAR, separated

# by a space.

if test yes = "$_G_HAVE_PLUSEQ_OP"; then

  eval 'func_append_quoted ()

  {

    $debug_cmd

    func_quote_arg pretty "$2"

    eval "$1+=\\ \$func_quote_arg_result"

  }'

else

  func_append_quoted ()

  {

    $debug_cmd

    func_quote_arg pretty "$2"

    eval "$1=\$$1\\ \$func_quote_arg_result"

  }

fi

# func_append_uniq VAR VALUE

# --------------------------

# Append unique VALUE onto the existing contents of VAR, assuming

# entries are delimited by the first character of VALUE.  For example:

#

#   func_append_uniq options " --another-option option-argument"

#

# will only append to $options if " --another-option option-argument "

# is not already present somewhere in $options already (note spaces at

# each end implied by leading space in second argument).

func_append_uniq ()

{

    $debug_cmd

    eval _G_current_value='`$ECHO $'$1'`'

    _G_delim=`expr "$2" : '\(.\)'`

    case $_G_delim$_G_current_value$_G_delim in

      *"$2$_G_delim"*) ;;

      *) func_append "$@" ;;

    esac

}

# func_arith TERM...

# ------------------

# Set func_arith_result to the result of evaluating TERMs.

  test -z "$_G_HAVE_ARITH_OP" \

    && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \

    && _G_HAVE_ARITH_OP=yes

if test yes = "$_G_HAVE_ARITH_OP"; then

  eval 'func_arith ()

  {

    $debug_cmd

    func_arith_result=$(( $* ))

  }'

else

  func_arith ()

  {

    $debug_cmd

    func_arith_result=`expr "$@"`

  }

fi

# func_basename FILE

# ------------------

# Set func_basename_result to FILE with everything up to and including

# the last / stripped.

if test yes = "$_G_HAVE_XSI_OPS"; then

  # If this shell supports suffix pattern removal, then use it to avoid

  # forking. Hide the definitions single quotes in case the shell chokes

  # on unsupported syntax...

  _b='func_basename_result=${1##*/}'

  _d='case $1 in

        */*) func_dirname_result=${1%/*}$2 ;;

        *  ) func_dirname_result=$3        ;;

      esac'

else

  # ...otherwise fall back to using sed.

  _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'

  _d='func_dirname_result=`$ECHO "$1"  |$SED "$sed_dirname"`

      if test "X$func_dirname_result" = "X$1"; then

        func_dirname_result=$3

      else

        func_append func_dirname_result "$2"

      fi'

fi

eval 'func_basename ()

{

    $debug_cmd

    '"$_b"'

}'

# func_dirname FILE APPEND NONDIR_REPLACEMENT

# -------------------------------------------

# Compute the dirname of FILE.  If nonempty, add APPEND to the result,

# otherwise set result to NONDIR_REPLACEMENT.

eval 'func_dirname ()

{

    $debug_cmd

    '"$_d"'

}'

# func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT

# --------------------------------------------------------

# Perform func_basename and func_dirname in a single function

# call:

#   dirname:  Compute the dirname of FILE.  If nonempty,

#             add APPEND to the result, otherwise set result

#             to NONDIR_REPLACEMENT.

#             value returned in "$func_dirname_result"

#   basename: Compute filename of FILE.

#             value retuned in "$func_basename_result"

# For efficiency, we do not delegate to the functions above but instead

# duplicate the functionality here.

eval 'func_dirname_and_basename ()

{

    $debug_cmd

    '"$_b"'

    '"$_d"'

}'

# func_echo ARG...

# ----------------

# Echo program name prefixed message.

func_echo ()

{

    $debug_cmd

    _G_message=$*

    func_echo_IFS=$IFS

    IFS=$nl

    for _G_line in $_G_message; do

      IFS=$func_echo_IFS

      $ECHO "$progname: $_G_line"

    done

    IFS=$func_echo_IFS

}

# func_echo_all ARG...

# --------------------

# Invoke $ECHO with all args, space-separated.

func_echo_all ()

{

    $ECHO "$*"

}

# func_echo_infix_1 INFIX ARG...

# ------------------------------

# Echo program name, followed by INFIX on the first line, with any

# additional lines not showing INFIX.

func_echo_infix_1 ()

{

    $debug_cmd

    $require_term_colors

    _G_infix=$1; shift

    _G_indent=$_G_infix

    _G_prefix="$progname: $_G_infix: "

    _G_message=$*

    # Strip color escape sequences before counting printable length

    for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan"

    do

      test -n "$_G_tc" && {

        _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"`

        _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"`

      }

    done

    _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`"  " ## exclude from sc_prohibit_nested_quotes

    func_echo_infix_1_IFS=$IFS

    IFS=$nl

    for _G_line in $_G_message; do

      IFS=$func_echo_infix_1_IFS

      $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2

      _G_prefix=$_G_indent

    done

    IFS=$func_echo_infix_1_IFS

}

# func_error ARG...

# -----------------

# Echo program name prefixed message to standard error.

func_error ()

{

    $debug_cmd

    $require_term_colors

    func_echo_infix_1 "  $tc_standout${tc_red}error$tc_reset" "$*" >&2

}

# func_fatal_error ARG...

# -----------------------

# Echo program name prefixed message to standard error, and exit.

func_fatal_error ()

{

    $debug_cmd

    func_error "$*"

    exit $EXIT_FAILURE

}

# func_grep EXPRESSION FILENAME

# -----------------------------

# Check whether EXPRESSION matches any line of FILENAME, without output.

func_grep ()

{

    $debug_cmd

    $GREP "$1" "$2" >/dev/null 2>&1

}

# func_len STRING

# ---------------

# Set func_len_result to the length of STRING. STRING may not

# start with a hyphen.

  test -z "$_G_HAVE_XSI_OPS" \

    && (eval 'x=a/b/c;

      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \

    && _G_HAVE_XSI_OPS=yes

if test yes = "$_G_HAVE_XSI_OPS"; then

  eval 'func_len ()

  {

    $debug_cmd

    func_len_result=${#1}

  }'

else

  func_len ()

  {

    $debug_cmd

    func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`

  }

fi

# func_mkdir_p DIRECTORY-PATH

# ---------------------------

# Make sure the entire path to DIRECTORY-PATH is available.

func_mkdir_p ()

{

    $debug_cmd

    _G_directory_path=$1

    _G_dir_list=

    if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then

      # Protect directory names starting with '-'

      case $_G_directory_path in

        -*) _G_directory_path=./$_G_directory_path ;;

      esac

      # While some portion of DIR does not yet exist...

      while test ! -d "$_G_directory_path"; do

        # ...make a list in topmost first order.  Use a colon delimited

	# list incase some portion of path contains whitespace.

        _G_dir_list=$_G_directory_path:$_G_dir_list

        # If the last portion added has no slash in it, the list is done

        case $_G_directory_path in */*) ;; *) break ;; esac

        # ...otherwise throw away the child directory and loop

        _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"`

      done

      _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'`

      func_mkdir_p_IFS=$IFS; IFS=:

      for _G_dir in $_G_dir_list; do

	IFS=$func_mkdir_p_IFS

        # mkdir can fail with a 'File exist' error if two processes

        # try to create one of the directories concurrently.  Don't