# libtool (GNU libtool) 2.4.2

# libtool (GNU libtool) 2.4.3

# Provide generalized library-building support services.

# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,

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

# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.

# along with GNU Libtool; see the file COPYING.  If not, a copy

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

# can be downloaded from http://www.gnu.org/licenses/gpl.html,

# or obtained by writing to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

VERSION=2.4.2

VERSION=2.4.3

TIMESTAMP=""

package_revision=2.4.3

package_revision=1.3337

# Be Bourne compatible

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

## ------ ##

## 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=2014-01-03.01; # UTC

# General shell script boiler plate, and helper functions.

# Written by Gary V. Vaughan, 2004

# Copyright (C) 2004-2014 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.

# This program 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 3 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.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNES 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/>.

# Please report bugs or propose patches to gary@gnu.org.

## ------ ##

## 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 :

  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which

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

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

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

# NLS nuisances: We save the old values to restore during execute mode.

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

lt_user_locale=

_G_user_locale=

lt_safe_locale=

_G_safe_locale=

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

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

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

          save_$lt_var=\$$lt_var

          save_$_G_var=\$$_G_var

          $lt_var=C

          $_G_var=C

	  export $lt_var

	  export $_G_var

	  lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"

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

	  lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"

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

$lt_unset CDPATH

# CDPATH.

(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

# Make sure IFS has a sensible default

sp=' '

nl='

'

IFS="$sp	$nl"

test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}

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

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

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

: ${LN_S="ln -s"}

# func_dirname file append nondir_replacement

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

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

## Useful sed snippets. ##

# otherwise set result to NONDIR_REPLACEMENT.

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

func_dirname ()

{

    func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`

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

      func_dirname_result="${3}"

    else

      func_dirname_result="$func_dirname_result${2}"

    fi

} # func_dirname may be replaced by extended shell implementation

# func_basename file

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

func_basename ()

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

{

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

    func_basename_result=`$ECHO "${1}" | $SED "$basename"`

} # func_basename may be replaced by extended shell implementation

# func_dirname_and_basename file append nondir_replacement

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

# perform func_basename and func_dirname in a single function

# string literally.

# call:

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

#   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"

# Implementation must be kept synchronized with func_dirname

# and func_basename. For efficiency, we do not delegate to

# those functions but instead duplicate the functionality here.

func_dirname_and_basename ()

{

    # Extract subdirectory from the argument.

    func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`

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

      func_dirname_result="${3}"

    else

      func_dirname_result="$func_dirname_result${2}"

    fi

    func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`

} # func_dirname_and_basename may be replaced by extended shell implementation

# func_stripname prefix suffix name

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

# strip PREFIX and SUFFIX off of NAME.

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

# PREFIX and SUFFIX must not contain globbing or regex special

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

# characters, hashes, percent signs, but SUFFIX may contain a leading

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

# dot (in which case that matches only a dot).

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

# func_strip_suffix prefix name

_G_bs='\\'

func_stripname ()

_G_bs2='\\\\'

{

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

    case ${2} in

_G_dollar='\$'

      .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;

sed_double_backslash="\

      *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;

  s/$_G_bs4/&\\

    esac

/g

} # func_stripname may be replaced by extended shell implementation

  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"

# These SED scripts presuppose an absolute path with a trailing slash.

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

pathcar='s,^/\([^/]*\).*$,\1,'

## Global variables. ##

pathcdr='s,^/[^/]*,,'

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

removedotparts=':dotsl

		s@/\./@/@g

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

		t dotsl

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

		s,/\.$,/,'

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

collapseslashes='s@/\{1,\}@/@g'

# this file will not pollute your global namespace with anything

finalslash='s,/*$,/,'

# 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.

# func_normal_abspath PATH

EXIT_SUCCESS=0

# Remove doubled-up and trailing slashes, "." path components,

EXIT_FAILURE=1

# and cancel out any ".." path components in PATH after making

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

# it an absolute path.

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

#             value returned in "$func_normal_abspath_result"

func_normal_abspath ()

{

  # Start from root dir and reassemble the path.

  func_normal_abspath_result=

  func_normal_abspath_tpath=$1

  func_normal_abspath_altnamespace=

  case $func_normal_abspath_tpath in

    "")

      # Empty path, that just means $cwd.

      func_stripname '' '/' "`pwd`"

      func_normal_abspath_result=$func_stripname_result

      return

    ;;

    # The next three entries are used to spot a run of precisely

    # two leading slashes without using negated character classes;

    # we take advantage of case's first-match behaviour.

    ///*)

      # Unusual form of absolute path, do nothing.

    ;;

    //*)

      # Not necessarily an ordinary path; POSIX reserves leading '//'

      # and for example Cygwin uses it to access remote file shares

      # over CIFS/SMB, so we conserve a leading double slash if found.

      func_normal_abspath_altnamespace=/

    ;;

    /*)

      # Absolute path, do nothing.

    ;;

    *)

      # Relative path, prepend $cwd.

      func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath

    ;;

  esac

  # Cancel out all the simple stuff to save iterations.  We also want

  # the path to end with a slash for ease of parsing, so make sure

  # there is one (and only one) here.

  func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \

        -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`

  while :; do

    # Processed it all yet?

    if test "$func_normal_abspath_tpath" = / ; then

      # If we ascended to the root using ".." the result may be empty now.

      if test -z "$func_normal_abspath_result" ; then

        func_normal_abspath_result=/

      fi

      break

    fi

    func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \

        -e "$pathcar"`

    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \

        -e "$pathcdr"`

    # Figure out what to do with it

    case $func_normal_abspath_tcomponent in

      "")

        # Trailing empty path component, ignore it.

      ;;

      ..)

        # Parent dir; strip last assembled component from result.

        func_dirname "$func_normal_abspath_result"

        func_normal_abspath_result=$func_dirname_result

      ;;

      *)

        # Actual path component, append it.

        func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent

      ;;

    esac

  done

  # Restore leading double-slash if one was found on entry.

  func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result

}

# func_relative_path SRCDIR DSTDIR

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

# generates a relative path from SRCDIR to DSTDIR, with a trailing

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

# slash if non-empty, suitable for immediately appending a filename

# bash to show function call trace with:

# without needing to append a separator.

#

#             value returned in "$func_relative_path_result"

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

func_relative_path ()

debug_cmd=${debug_cmd-":"}

{

exit_cmd=:

  func_relative_path_result=

  func_normal_abspath "$1"

  func_relative_path_tlibdir=$func_normal_abspath_result

  func_normal_abspath "$2"

  func_relative_path_tbindir=$func_normal_abspath_result

  # Ascend the tree starting from libdir

  while :; do

    # check if we have found a prefix of bindir

    case $func_relative_path_tbindir in

      $func_relative_path_tlibdir)

        # found an exact match

        func_relative_path_tcancelled=

        break

        ;;

      $func_relative_path_tlibdir*)

        # found a matching prefix

        func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"

        func_relative_path_tcancelled=$func_stripname_result

        if test -z "$func_relative_path_result"; then

          func_relative_path_result=.

        fi

        break

        ;;

      *)

        func_dirname $func_relative_path_tlibdir

        func_relative_path_tlibdir=${func_dirname_result}

        if test "x$func_relative_path_tlibdir" = x ; then

          # Have to descend all the way to the root!

          func_relative_path_result=../$func_relative_path_result

          func_relative_path_tcancelled=$func_relative_path_tbindir

          break

        fi

        func_relative_path_result=../$func_relative_path_result

        ;;

    esac

  done

  # Now calculate path; take care to avoid doubling-up slashes.

# By convention, finish your script with:

  func_stripname '' '/' "$func_relative_path_result"

#

  func_relative_path_result=$func_stripname_result

#    exit $exit_status

  func_stripname '/' '/' "$func_relative_path_tcancelled"

#

  if test "x$func_stripname_result" != x ; then

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

    func_relative_path_result=${func_relative_path_result}/${func_stripname_result}

# something went wrong during execution without actually bailing out at

  fi

# the point of failure.

exit_status=$EXIT_SUCCESS

  # Normalisation. If bindir is libdir, return empty string,

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

  # else relative path ending with a slash; either way, target

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

  # file name can be directly appended.

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

  if test ! -z "$func_relative_path_result"; then

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

    func_stripname './' '' "$func_relative_path_result/"

# function.

    func_relative_path_result=$func_stripname_result

progpath=$0

  fi

}

# The name of this program:

# The name of this program.

func_dirname_and_basename "$progpath"

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

progname=$func_basename_result

# Make sure we have an absolute path for reexecution:

# Make sure we have an absolute progpath for reexecution:

     progdir=$func_dirname_result

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

     progpath="$progdir/$progname"

     progpath=$progdir/$progname

     save_IFS="$IFS"

     _G_IFS=$IFS

       IFS="$save_IFS"

       IFS=$_G_IFS

     IFS="$save_IFS"

     IFS=$_G_IFS

     progpath="$progdir/$progname"

     progpath=$progdir/$progname

# Sed substitution that converts a w32 file name or path

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

# which contains forward slashes, into one that contains

## Standard options. ##

# (escaped) backslashes.  A very naive implementation.

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

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

# The following options affect the operation of the functions defined

# Re-`\' parameter expansions in output of double_quote_subst that were

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

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

# meters passed on the command line.

# in input to 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 '$'.

bs='\\'

bs2='\\\\'

bs4='\\\\\\\\'

dollar='\$'

sed_double_backslash="\

  s/$bs4/&\\

/g

  s/^$bs2$dollar/$bs&/

  s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g

  s/\n//g"

# func_verbose arg...

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

# Echo program name prefixed message in verbose mode only.

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

func_verbose ()

# code.

{

warning_categories=

    $opt_verbose && func_echo ${1+"$@"}

# 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

    }

    # A bug in bash halts the script if the last line of a function

    require_term_colors=:

    # fails when set -e is in force, so we need another command to

    # work around that:

    :

# func_error arg...

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

# Echo program name prefixed message to standard error.

## Function library. ##

func_error ()

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

{

    $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2

}

# func_warning arg...

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

# Echo program name prefixed warning message to standard error.

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

func_warning ()

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

{

# less featureful shells.

    $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2

# func_fatal_error arg...

# func_append VAR VALUE

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

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

func_fatal_error ()

# Append VALUE onto the existing contents of VAR.

{

    func_error ${1+"$@"}

    exit $EXIT_FAILURE

}

# func_fatal_help arg...

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

# Echo program name prefixed message to standard error, followed by

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

# a help hint, and exit.

  # being used:

func_fatal_help ()

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

{

    : ${_G_HAVE_ARITH_OP="yes"}

    func_error ${1+"$@"}

    : ${_G_HAVE_XSI_OPS="yes"}

    func_fatal_error "$help"

    # The += operator was introduced in bash 3.1

}

    case $BASH_VERSION in

help="Try \`$progname --help' for more information."  ## default

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

      *)

        : ${_G_HAVE_PLUSEQ_OP="yes"}

        ;;

    esac

  fi

# func_grep expression filename

    func_error "$*"

    exit $EXIT_FAILURE

}

# func_grep EXPRESSION FILENAME

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

# func_mkdir_p directory-path

# func_len STRING

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

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

func_mkdir_p ()

# 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

        # stop in that case!

        $MKDIR "$_G_dir" 2>/dev/null || :

      done

      IFS=$func_mkdir_p_IFS

      # Bail out if we (or some other process) failed to create a directory.

      test -d "$_G_directory_path" || \

        func_fatal_error "Failed to create '$1'"

    fi

}

# func_mktempdir [BASENAME]

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

# Make a temporary directory that won't clash with other running

# libtool processes, and avoids race conditions if possible.  If

# given, BASENAME is the basename for that directory.

func_mktempdir ()

{

    $debug_cmd

    _G_template=${TMPDIR-/tmp}/${1-$progname}

    if test : = "$opt_dry_run"; then

      # Return a directory name, but don't create it in dry-run mode

      _G_tmpdir=$_G_template-$$

    else

      # If mktemp works, use that first and foremost

      _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null`

      if test ! -d "$_G_tmpdir"; then

        # Failing that, at least try and use $RANDOM to avoid a race

        _G_tmpdir=$_G_template-${RANDOM-0}$$

        func_mktempdir_umask=`umask`

        umask 0077

        $MKDIR "$_G_tmpdir"

        umask $func_mktempdir_umask

      fi

      # If we're not in dry-run mode, bomb out on failure

      test -d "$_G_tmpdir" || \

        func_fatal_error "cannot create temporary directory '$_G_tmpdir'"

    fi

    $ECHO "$_G_tmpdir"

}

# func_normal_abspath PATH

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

# Remove doubled-up and trailing slashes, "." path components,

# and cancel out any ".." path components in PATH after making

# it an absolute path.

func_normal_abspath ()

{

    $debug_cmd

    # These SED scripts presuppose an absolute path with a trailing slash.

    _G_pathcar='s|^/\([^/]*\).*$|\1|'

    _G_pathcdr='s|^/[^/]*||'

    _G_removedotparts=':dotsl

		s|/\./|/|g

		t dotsl

		s|/\.$|/|'

    _G_collapseslashes='s|/\{1,\}|/|g'

    _G_finalslash='s|/*$|/|'

    # Start from root dir and reassemble the path.

    func_normal_abspath_result=

    func_normal_abspath_tpath=$1

    func_normal_abspath_altnamespace=

    case $func_normal_abspath_tpath in

      "")

        # Empty path, that just means $cwd.

        func_stripname '' '/' "`pwd`"

        func_normal_abspath_result=$func_stripname_result

        return

        ;;

      # The next three entries are used to spot a run of precisely

      # two leading slashes without using negated character classes;

      # we take advantage of case's first-match behaviour.

      ///*)

        # Unusual form of absolute path, do nothing.

        ;;

      //*)

        # Not necessarily an ordinary path; POSIX reserves leading '//'

        # and for example Cygwin uses it to access remote file shares

        # over CIFS/SMB, so we conserve a leading double slash if found.

        func_normal_abspath_altnamespace=/

        ;;

      /*)

        # Absolute path, do nothing.

        ;;

      *)

        # Relative path, prepend $cwd.

        func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath

        ;;

    esac

    # Cancel out all the simple stuff to save iterations.  We also want

    # the path to end with a slash for ease of parsing, so make sure

    # there is one (and only one) here.

    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \

          -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`

    while :; do

      # Processed it all yet?

      if test / = "$func_normal_abspath_tpath"; then

        # If we ascended to the root using ".." the result may be empty now.

        if test -z "$func_normal_abspath_result"; then

          func_normal_abspath_result=/

        fi

        break

      fi

      func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \

          -e "$_G_pathcar"`

      func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \

          -e "$_G_pathcdr"`

      # Figure out what to do with it

      case $func_normal_abspath_tcomponent in

        "")

          # Trailing empty path component, ignore it.

          ;;

        ..)

          # Parent dir; strip last assembled component from result.

          func_dirname "$func_normal_abspath_result"

          func_normal_abspath_result=$func_dirname_result

          ;;

        *)

          # Actual path component, append it.

          func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent"

          ;;

      esac

    done

    # Restore leading double-slash if one was found on entry.

    func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result

}

# func_notquiet ARG...

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

# Echo program name prefixed message only when not in quiet mode.

func_notquiet ()

{

    $debug_cmd

    $opt_quiet || func_echo ${1+"$@"}

    # A bug in bash halts the script if the last line of a function

    # fails when set -e is in force, so we need another command to

    # work around that:

    :

}

# func_relative_path SRCDIR DSTDIR

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

# Set func_relative_path_result to the relative path from SRCDIR to DSTDIR.

func_relative_path ()

{

    $debug_cmd

    func_relative_path_result=

    func_normal_abspath "$1"

    func_relative_path_tlibdir=$func_normal_abspath_result

    func_normal_abspath "$2"

    func_relative_path_tbindir=$func_normal_abspath_result

    # Ascend the tree starting from libdir

    while :; do

      # check if we have found a prefix of bindir

      case $func_relative_path_tbindir in

        $func_relative_path_tlibdir)

          # found an exact match

          func_relative_path_tcancelled=

          break

          ;;

        $func_relative_path_tlibdir*)

          # found a matching prefix

          func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"

          func_relative_path_tcancelled=$func_stripname_result

          if test -z "$func_relative_path_result"; then

            func_relative_path_result=.

          fi

          break

          ;;

        *)

          func_dirname $func_relative_path_tlibdir

          func_relative_path_tlibdir=$func_dirname_result

          if test -z "$func_relative_path_tlibdir"; then

            # Have to descend all the way to the root!

            func_relative_path_result=../$func_relative_path_result

            func_relative_path_tcancelled=$func_relative_path_tbindir

            break

          fi

          func_relative_path_result=../$func_relative_path_result

          ;;

      esac

    done

    # Now calculate path; take care to avoid doubling-up slashes.

    func_stripname '' '/' "$func_relative_path_result"

    func_relative_path_result=$func_stripname_result

    func_stripname '/' '/' "$func_relative_path_tcancelled"

    if test -n "$func_stripname_result"; then

      func_append func_relative_path_result "/$func_stripname_result"

    fi

    # Normalisation. If bindir is libdir, return '.' else relative path.

    if test -n "$func_relative_path_result"; then

      func_stripname './' '' "$func_relative_path_result"

      func_relative_path_result=$func_stripname_result

    fi

    test -n "$func_relative_path_result" || func_relative_path_result=.

    :

}

# func_quote_for_eval ARG...

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

# Aesthetically quote ARGs to be evaled later.

# This function returns two values:

#   i) func_quote_for_eval_result

#      double-quoted, suitable for a subsequent eval

#  ii) func_quote_for_eval_unquoted_result

#      has all characters that are still active within double

#      quotes backslashified.

func_quote_for_eval ()

{

    $debug_cmd

    func_quote_for_eval_unquoted_result=

    func_quote_for_eval_result=

    while test 0 -lt $#; do

      case $1 in

        *[\\\`\"\$]*)

	  _G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;;

        *)

          _G_unquoted_arg=$1 ;;

      esac

      if test -n "$func_quote_for_eval_unquoted_result"; then

	func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg"

      else

        func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg"

      fi

      case $_G_unquoted_arg in

        # Double-quote args containing shell metacharacters to delay

        # word splitting, command substitution and variable expansion

        # for a subsequent eval.

        # Many Bourne shells cannot handle close brackets correctly

        # in scan sets, so we specify it separately.

        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

          _G_quoted_arg=\"$_G_unquoted_arg\"

          ;;

        *)

          _G_quoted_arg=$_G_unquoted_arg

	  ;;

      esac

      if test -n "$func_quote_for_eval_result"; then

	func_append func_quote_for_eval_result " $_G_quoted_arg"

      else

        func_append func_quote_for_eval_result "$_G_quoted_arg"

      fi

      shift

    done

}

# func_quote_for_expand ARG

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

# Aesthetically quote ARG to be evaled later; same as above,

# but do not quote variable references.

func_quote_for_expand ()

{

    $debug_cmd

    case $1 in

      *[\\\`\"]*)

	_G_arg=`$ECHO "$1" | $SED \

	    -e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;;

      *)

        _G_arg=$1 ;;

    esac

    case $_G_arg in

      # Double-quote args containing shell metacharacters to delay

      # word splitting and command substitution for a subsequent eval.

      # Many Bourne shells cannot handle close brackets correctly

      # in scan sets, so we specify it separately.

      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")

        _G_arg=\"$_G_arg\"

        ;;

    esac

    func_quote_for_expand_result=$_G_arg

}

# func_stripname PREFIX SUFFIX NAME

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

# strip PREFIX and SUFFIX from NAME, and store in func_stripname_result.

# PREFIX and SUFFIX must not contain globbing or regex special

# characters, hashes, percent signs, but SUFFIX may contain a leading

# dot (in which case that matches only a dot).

if test yes = "$_G_HAVE_XSI_OPS"; then

  eval 'func_stripname ()

  {

    $debug_cmd

    # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are

    # positional parameters, so assign one to ordinary variable first.

    func_stripname_result=$3

    func_stripname_result=${func_stripname_result#"$1"}

    func_stripname_result=${func_stripname_result%"$2"}

  }'

else

  func_stripname ()

  {

    $debug_cmd

    case $2 in

      .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;;

      *)  func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;;

    esac

  }

fi

# func_show_eval CMD [FAIL_EXP]

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

# Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is

# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP

# is given, then evaluate it.

func_show_eval ()

{

    $debug_cmd

    _G_cmd=$1

    _G_fail_exp=${2-':'}

    func_quote_for_expand "$_G_cmd"

    eval "func_notquiet $func_quote_for_expand_result"

    $opt_dry_run || {

      eval "$_G_cmd"

      _G_status=$?

      if test 0 -ne "$_G_status"; then

	eval "(exit $_G_status); $_G_fail_exp"

      fi

    }

}

# func_show_eval_locale CMD [FAIL_EXP]

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

# Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is

# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP

# is given, then evaluate it.  Use the saved locale for evaluation.

func_show_eval_locale ()

{

    $debug_cmd

    _G_cmd=$1

    _G_fail_exp=${2-':'}

    $opt_quiet || {

      func_quote_for_expand "$_G_cmd"

      eval "func_echo $func_quote_for_expand_result"

    }

    $opt_dry_run || {

      eval "$_G_user_locale

	    $_G_cmd"

      _G_status=$?

      eval "$_G_safe_locale"

      if test 0 -ne "$_G_status"; then

	eval "(exit $_G_status); $_G_fail_exp"

      fi

    }

}

# func_tr_sh

# ----------

# Turn $1 into a string suitable for a shell variable name.

# Result is stored in $func_tr_sh_result.  All characters

# not in the set a-zA-Z0-9_ are replaced with '_'. Further,

# if $1 begins with a digit, a '_' is prepended as well.

func_tr_sh ()

{

    $debug_cmd

    case $1 in

    [0-9]* | *[!a-zA-Z0-9_]*)

      func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'`

      ;;

    * )

      func_tr_sh_result=$1

      ;;

    esac

}

# func_verbose ARG...

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

# Echo program name prefixed message in verbose mode only.

func_verbose ()

{

    $debug_cmd

    $opt_verbose && func_echo "$*"

    :

}

# func_warn_and_continue ARG...

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

# Echo program name prefixed warning message to standard error.

func_warn_and_continue ()

{

    $debug_cmd

    $require_term_colors

    func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2

}

# func_warning CATEGORY ARG...

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

# Echo program name prefixed warning message to standard error. Warning

# messages can be filtered according to CATEGORY, where this function

# elides messages where CATEGORY is not listed in the global variable

# 'opt_warning_types'.

func_warning ()

{

    $debug_cmd

    # CATEGORY must be in the warning_categories list!

    case " $warning_categories " in

      *" $1 "*) ;;

      *) func_internal_error "invalid warning category '$1'" ;;

    esac

    _G_category=$1

    shift

    case " $opt_warning_types " in

      *" $_G_category "*) $warning_func ${1+"$@"} ;;

    esac

}

# func_sort_ver VER1 VER2

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

# 'sort -V' is not generally available.

# Note this deviates from the version comparison in automake

# in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a

# but this should suffice as we won't be specifying old

# version formats or redundant trailing .0 in bootstrap.conf.

# If we did want full compatibility then we should probably

# use m4_version_compare from autoconf.

func_sort_ver ()

{

    $debug_cmd

    printf '%s\n%s\n' "$1" "$2" \

      | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n

}

# func_lt_ver PREV CURR

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

# Return true if PREV and CURR are in the correct order according to

# func_sort_ver, otherwise false.  Use it like this:

#

#  func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..."

func_lt_ver ()

{

    $debug_cmd

    test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q`

}

# Local variables:

# mode: shell-script

# sh-indentation: 2

# eval: (add-hook 'before-save-hook 'time-stamp)

# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"

# time-stamp-time-zone: "UTC"

# End:

#! /bin/sh

# Set a version string for this script.

scriptversion=2014-01-07.03; # UTC

# A portable, pluggable option parser for Bourne shell.

# Written by Gary V. Vaughan, 2010

# Copyright (C) 2010-2014 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.

# This program 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 3 of the License, or

# (at your option) any later version.

# This program 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/>.

# Please report bugs or propose patches to gary@gnu.org.

## ------ ##

## Usage. ##

## ------ ##

# This file is a library for parsing options in your shell scripts along

# with assorted other useful supporting features that you can make use

# of too.

#

# For the simplest scripts you might need only:

#

#   #!/bin/sh

#   . relative/path/to/funclib.sh

#   . relative/path/to/options-parser

#   scriptversion=1.0

#   func_options ${1+"$@"}

#   eval set dummy "$func_options_result"; shift

#   ...rest of your script...

#

# In order for the '--version' option to work, you will need to have a

# suitably formatted comment like the one at the top of this file

# starting with '# Written by ' and ending with '# warranty; '.

#

# For '-h' and '--help' to work, you will also need a one line

# description of your script's purpose in a comment directly above the

# '# Written by ' line, like the one at the top of this file.

#

# The default options also support '--debug', which will turn on shell

# execution tracing (see the comment above debug_cmd below for another

# use), and '--verbose' and the func_verbose function to allow your script

# to display verbose messages only when your user has specified

# '--verbose'.

#

# After sourcing this file, you can plug processing for additional

# options by amending the variables from the 'Configuration' section

# below, and following the instructions in the 'Option parsing'

# section further down.

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

## Configuration. ##

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

# You should override these variables in your script after sourcing this

# file so that they reflect the customisations you have added to the

# option parser.

# The usage line for option parsing errors and the start of '-h' and

# '--help' output messages. You can embed shell variables for delayed

# expansion at the time the message is displayed, but you will need to

# quote other shell meta-characters carefully to prevent them being

# expanded when the contents are evaled.

usage='$progpath [OPTION]...'

# Short help message in response to '-h' and '--help'.  Add to this or

# override it after sourcing this library to reflect the full set of

# options your script accepts.

usage_message="\

       --debug        enable verbose shell tracing

   -W, --warnings=CATEGORY

                      report the warnings falling in CATEGORY [all]

   -v, --verbose      verbosely report processing

       --version      print version information and exit

   -h, --help         print short or long help message and exit

"

# Additional text appended to 'usage_message' in response to '--help'.

long_help_message="

Warning categories include:

       'all'          show all warnings

       'none'         turn off all the warnings

       'error'        warnings are treated as fatal errors"

# Help message printed before fatal option parsing errors.

fatal_help="Try '\$progname --help' for more information."

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

## Hook function management. ##

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

# This section contains functions for adding, removing, and running hooks

# to the main code.  A hook is just a named list of of function, that can

# be run in order later on.

# func_hookable FUNC_NAME

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

# Declare that FUNC_NAME will run hooks added with

# 'func_add_hook FUNC_NAME ...'.

func_hookable ()

{

    $debug_cmd

    func_append hookable_fns " $1"

}

# func_add_hook FUNC_NAME HOOK_FUNC

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

# Request that FUNC_NAME call HOOK_FUNC before it returns.  FUNC_NAME must

# first have been declared "hookable" by a call to 'func_hookable'.

func_add_hook ()

{

    $debug_cmd

    case " $hookable_fns " in

      *" $1 "*) ;;

      *) func_fatal_error "'$1' does not accept hook functions." ;;

    esac

    eval func_append ${1}_hooks '" $2"'

}

# func_remove_hook FUNC_NAME HOOK_FUNC

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

# Remove HOOK_FUNC from the list of functions called by FUNC_NAME.

func_remove_hook ()

    my_directory_path="$1"