libtool/bootstrap

#! /bin/sh
# Print a version string.
scriptversion=2011-10-22.09; # UTC

# Bootstrap this package from checked-out sources.
# Written by Gary V. Vaughan, 2010

# Copyright (C) 2010, 2011 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/>.

# Originally written by Paul Eggert.  The canonical version of this
# script is maintained as build-aux/bootstrap in gnulib, however, to
# be useful to your project, you should place a copy of it under
# version control in the top-level directory of your project.  The
# intent is that all customization can be done with a bootstrap.conf
# file also maintained in your version control; gnulib comes with a
# template build-aux/bootstrap.conf to get you started.

# Please report bugs or propose patches to bug-gnulib@gnu.org.


## ================================================================== ##
##                                                                    ##
##     DO NOT EDIT THIS FILE, CUSTOMIZE IT USING A BOOTSTRAP.CONF     ##
##                                                                    ##
## ================================================================== ##

## ------------------------------- ##
## User overridable command paths. ##
## ------------------------------- ##

# All uppercase denotes values stored in the environment.  These
# variables should generally be overridden by the user - however, we do
# set them to `true' in some parts of this script to prevent them being
# called at the wrong time by other tools that we call (`autoreconf',
# for example).
#
# We also allow `LIBTOOLIZE' and `M4' to be overridden, and export the
# result for child processes, but they are handled by the function
# `func_find_tool' and not defaulted in this section.

: ${ACLOCAL="aclocal"}
: ${AUTOCONF="autoconf"}
: ${AUTOHEADER="autoheader"}
: ${AUTOM4TE="autom4te"}
: ${AUTOHEADER="autoheader"}
: ${AUTOMAKE="automake"}
: ${AUTOPOINT="autopoint"}
: ${AUTORECONF="autoreconf"}
: ${CMP="cmp"}
: ${CONFIG_SHELL="/bin/sh"}
: ${DIFF="diff"}
: ${EGREP="grep -E"}
: ${FGREP="grep -F"}
: ${GIT="git"}
: ${GREP="grep"}
: ${LN_S="ln -s"}
: ${RM="rm"}
: ${SED="sed"}

export ACLOCAL
export AUTOCONF
export AUTOHEADER
export AUTOM4TE
export AUTOHEADER
export AUTOMAKE
export AUTOPOINT
export AUTORECONF
export CONFIG_SHELL


## -------------- ##
## Configuration. ##
## -------------- ##

# Short help message in response to `-h'.  Add to this in `bootstrap.conf'
# if you accept any additional options.
usage_message="Bootstrap this package from the checked-out sources.

Common Bootstrap Options:
  -c, --copy         copy files instead of creating symbolic links.
      --debug        enable verbose shell tracing
  -n, --dry-run      print commands rather than running them
  -f, --force        attempt to bootstrap even if the sources seem not to have
                     been checked out.
      --gnulib-srcdir=DIRNAME
                     specify a local directory where gnulib sources reside.
                     Use this if you already have the gnulib sources on your
                     machine, and don't want to waste your bandwidth
                     downloading them again.  Defaults to \$GNULIB_SRCDIR.
      --skip-git     do not fetch files from remote repositories
      --skip-po      do not download po files.
  -v, --verbose      verbosely report processing
      --version      print version information and exit
  -W, --warnings=CATEGORY
                     report the warnings falling in CATEGORY [all]
  -h, --help         print short or long help message and exit
"

# Warning categories used by `bootstrap', append others if you use them
# in your `bootstrap.conf'.
warning_categories="recommend settings upgrade"

# 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
  \`recommend'     show warnings about missing recommended packages
  \`settings'      show warnings about missing \`bootstrap.conf' settings
  \`upgrade'       show warnings about out-dated files

If the file $progpath.conf exists in the same directory as this script, its
contents are read as shell variables to configure the bootstrap.

For build prerequisites, environment variables like \$AUTOCONF and \$AMTAR
are honored.

Running without arguments will suffice in most cases.
"

# A newline delimited list of triples of programs (that respond to
# --version), the minimum version numbers required (or just `-' in the
# version field if any version will be sufficient) and homepage URLs
# to help locate missing packages.
buildreq=

# Name of a file containing instructions on installing missing packages
# required in `buildreq'.
buildreq_readme=README-hacking

# These are extracted from AC_INIT in configure.ac, though you can
# override those values in `bootstrap.conf' if you prefer.
build_aux=
macro_dir=
package=
package_name=
package_version=
package_bugreport=

# These are extracted from `gnulib-cache.m4', or else fall-back
# automatically on the gnulib defaults; unless you set the values
# manually in `bootstrap.conf'.
doc_base=
gnulib_mk=
gnulib_name=
local_gl_dir=
source_base=
tests_base=

# The list of gnulib modules required at `gnulib-tool' time.  If you
# check `gnulib-cache.m4' into your repository, then this list will be
# extracted automatically.
gnulib_modules=

# Extra gnulib files that are not in modules, which override files of
# the same name installed by other bootstrap tools.
gnulib_non_module_files="
        build-aux/compile
        build-aux/install-sh
        build-aux/missing
        build-aux/mdate-sh
        build-aux/texinfo.tex
        build-aux/depcomp
        build-aux/config.guess
        build-aux/config.sub
        doc/INSTALL
"

# Relative path to the local gnulib submodule, and url to the upstream
# git repository. If you have a gnulib entry in your .gitmodules file,
# these values are ignored.
gnulib_path=
gnulib_url=

# Additional gnulib-tool options to use.
gnulib_tool_options="
        --no-changelog
"

# bootstrap removes any macro-files that are not included by aclocal.m4,
# except for files listed in this variable which are always kept.
gnulib_precious="
        gnulib-tool.m4
"

# When truncating long commands for display, always allow at least this
# many characters before truncating.
min_cmd_len=160

# The command to download all .po files for a specified domain into
# a specified directory.  Fill in the first %s is the domain name, and
# the second with the destination directory.  Use rsync's -L and -r
# options because the latest/%s directory and the .po files within are
# all symlinks.
po_download_command_format=\
"rsync --delete --exclude '*.s1' -Lrtvz \
'translationproject.org::tp/latest/%s/' '%s'"

# Other locale categories that need message catalogs.
extra_locale_categories=

# Additional xgettext options to use.  Gnulib might provide you with an
# extensive list of additional options to append to this, but gettext
# 0.16.1 and newer appends them automaticaly, so you can safely ignore
# the complaints from `gnulib-tool' if your $configure_ac states:
#
#    AM_GNU_GETTEXT_VERSION([0.16.1])
xgettext_options="
        --flag=_:1:pass-c-format
        --flag=N_:1:pass-c-format
"

# Package copyright holder for gettext files.  Defaults to FSF if unset.
copyright_holder=

# File that should exist in the top directory of a checked out hierarchy,
# but not in a distribution tarball.
checkout_only_file=

# Whether to use copies instead of symlinks by default (if set to true,
# the --copy option has no effect).
copy=false

# Set this to ".cvsignore .gitignore" in `bootstrap.conf' if you want
# those files to be generated in directories like `lib/', `m4/', and `po/',
# or set it to "auto" to make this script select which to use based
# on which version control system (if any) is used in the source directory.
# Or set it to "none" to ignore VCS ignore files entirely.  Default is
# "auto".
vc_ignore=


## -------------------- ##
## Shell normalisation. ##
## -------------------- ##

# Be more Bourne compatible
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.
LANGUAGE=C
export LANGUAGE

# Ensure file names are sorted consistently across platforms.
LC_ALL=C
export LC_ALL

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

# FIXME: check that $SED accepts comments, or bail out with a pointer
#        to GNU sed


## ------------------------- ##
## 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_append VAR VALUE
# ---------------------
# Append VALUE onto the existing contents of VAR.
if (eval 'x=a; x+=" b"; test "x$x" = "xa b"') 2>/dev/null
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_hookable FUNC_NAME
# -----------------------
# Declare that FUNC_NAME will run hooks added with
# `func_add_hook FUNC_NAME ...'.
func_hookable ()
{
    $debug_cmd

    func_append hookable_funcs " $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 coll to `func_hookable'.
func_add_hook ()
{
    $debug_cmd

    case " $hookable_funcs " in
      *" $1 "*) ;;
      *) func_fatal_error "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 ()
{
    $debug_cmd

    eval ${1}_hooks='`echo "\$'$1'_hooks" |$SED "s| '$2'||"`'
}


# func_run_hooks FUNC_NAME [ARG]...
# ---------------------------------
# Run all hook functions registered to FUNC_NAME.
# It is assumed that the list of hook functions contains nothing more
# than a whitespace-delimited list of legal shell function names, and
# no effort is wasted trying to catch shell meta-characters or preserve
# whitespace.
func_run_hooks ()
{
    $debug_cmd

    case " $hookable_funcs " in
      *" $1 "*) ;;
      *) func_fatal_error "error: \`$1' does not support hook funcions.n" ;;
    esac

    eval hook_funcs="\$$1_hooks"

    # shift away the first argument (FUNC_NAME)
    shift
    func_run_hooks_result=$*

    for hook_func in $hook_funcs; do
      eval $hook_func '"$@"'

      # store returned options list back into positional
      # parameters for next `cmd' execution.
      set dummy $func_run_hooks_result; shift
    done
}


## ------------------- ##
## Hookable functions. ##
## ------------------- ##

# After `bootstrap.conf' has been sourced, execution proceeds by calling
# `func_bootstrap'.  Where a function is decorated with `func_hookable
# func_name', you will find a matching `func_run_hooks func_name' which
# executes all functions added with `func_add_hook func_name my_func'.
#
# You might notice that many of these functions begin with a series of
# `$require_foo' lines.  See the docu-comments at the start of the
# `Resource management' section for a description of what these are.


# func_bootstrap [ARG]...
# -----------------------
# All the functions called inside func_bootstrap are hookable. See the
# the individual implementations for details.
func_bootstrap ()
{
    $debug_cmd

    # Save the current positional parameters to prevent them being
    # corrupted by calls to `set' in `func_init'.
    func_quote_for_eval ${1+"$@"}
    my_saved_positional_parameters="$func_quote_for_eval_result"

    # Initialisation.
    func_init

    # Option processing.
    eval func_options "$my_saved_positional_parameters"

    # Post-option preparation.
    func_prep

    # Ensure ChangeLog presence.
    func_ifcontains "$gnulib_modules" gitlog-to-changelog \
      func_ensure_changelog

    # Reconfigure the package.
    func_reconfigure

    # Ensure .version is up-to-date.
    func_update_dotversion

    # Finalisation.
    func_fini
}


# func_init
# ---------
# Any early initialisations can be hooked to this function.  Consider
# whether you can hook onto `func_prep' instead, because if you hook
# any slow to execute code in here, it will also add to the time before
# `./bootstrap --version' can respond.
func_hookable func_init
func_init ()
{
    $debug_cmd

    func_run_hooks func_init
}


# func_options [ARG]...
# ---------------------
# All the functions called inside func_options are hookable. See the
# individual implementations for details.
func_hookable func_options
func_options ()
{
    $debug_cmd

    func_options_prep ${1+"$@"}
    eval func_parse_options \
        ${func_options_prep_result+"$func_options_prep_result"}
    eval func_validate_options \
        ${func_parse_options+"$func_parse_options_result"}

    eval func_run_hooks func_options \
        ${func_validate_options_result+"$func_validate_options_result"}

    # save modified positional parameters for caller
    func_options_result="$func_run_hooks_result"
}


# func_options_prep [ARG]...
# --------------------------
# All initialisations required before starting the option parse loop.
# Note that when calling hook functions, we pass through the list of
# positional parameters.  If a hook function modifies that list, and
# needs to propogate that back to rest of this script, then the complete
# modified list must be put in `func_run_hooks_result' before
# returning.
func_hookable func_options_prep
func_options_prep ()
{
    $debug_cmd

    warning_func=func_error

    # Option defaults:
    opt_copy=${copy-false}
    opt_dry_run=false
    opt_force=false
    opt_gnulib_srcdir="$GNULIB_SRCDIR"
    opt_skip_git=false
    opt_skip_po=false
    opt_warning=
    opt_verbose=false

    func_run_hooks func_options_prep ${1+"$@"}

    # save modified positional parameters for caller
    func_options_prep_result="$func_run_hooks_result"
}


# func_parse_options [ARG]...
# ---------------------------
# The main option parsing loop.
#
# In order to add your own option parsing hooks, you must accept the
# full positional parameter list in your hook function, remove any
# options that you action, and then pass back the remaining unprocessed
# options in `func_run_hooks_result', escaped suitably for `eval'.  Like
# this:
#
#    my_silent_option ()
#    {
#        $debug_cmd
#
#        case $1 in
#          --silent|-s) opt_silent=:; shift ;;
#        esac
#
#        func_quote_for_eval ${1+"$@"}
#        func_run_hooks_result="$func_quote_for_eval_result"
#    }
#    func_add_hook func_parse_options my_silent_option
#
func_hookable func_parse_options
func_parse_options ()
{
    $debug_cmd

    func_parse_options_result=

    # this just eases exit handling
    while test $# -gt 0; do

      # Defer to hook functions for initial option parsing, so they
      # get priority in the event of reusing an option name.
      func_run_hooks func_parse_options ${1+"$@"}

      # Adjust func_parse_options positional parameters to match
      eval set dummy "$func_run_hooks_result"; shift

      opt="$1"
      shift
      case $opt in
        --debug|-x)   debug_cmd='set -x'
                      func_echo "enabling shell trace mode"
                      $debug_cmd
                      ;;
        --dry-run|--dryrun|-n)
                      opt_dry_run=: ;;
        --copy|-c)    opt_copy=: ;;
        --force|-f)   opt_force=: ;;

        --gnulib-srcdir)
                      test $# = 0 && func_missing_arg $opt && break
                      opt_gnulib_srcdir="$1"
                      shift
                      ;;

        --skip-git)   opt_skip_git=: ;;
        --skip-po)    opt_skip_po=: ;;
        --verbose|-v) opt_verbose=: ;;

        --warnings|--warning|-W)
                      test $# = 0 && func_missing_arg $opt && break
                      case " $1 " in
                        " all ")
                          opt_warning=" $warning_categories"
                          ;;
                        " none ")
                          opt_warning=" none"
                          warning_func=:
                          ;;
                        " error ")
                          warning_func=func_fatal_error
                          ;;
                        *" $warning_categories "*)
                          func_append_u opt_warning " $1"
                          ;;
                        *)
                          func_fatal_error \
                             "error: unsupported warning category: \`$1'"
                          ;;
                      esac
                      shift
                      ;;

        --version)    func_version ;;
        -\?|-h)       func_usage ;;
        --help)       func_help ;;

        # Separate optargs to long options:
        --*=*)
                      func_split_equals "$opt"
                      set dummy "$func_split_equals_lhs" \
                         "$func_split_equals_rhs" ${1+"$@"}
                      shift
                      ;;

        # Separate optargs to short options:
        -W*)
                      func_split_short_opt "$opt"
                      set dummy "$func_split_short_opt_name" \
                          "$func_split_short_opt_arg" ${1+"$@"}
                      shift
                      ;;

        # Separate non-argument short options:
        -\?*|-h*|-c*|-f*|-n*|-v*|-x*)
                      func_split_short_opt "$opt"
                      set dummy "$func_split_short_opt_name" \
                          "-$func_split_short_opt_arg" ${1+"$@"}
                      shift
                      ;;

        --)           set dummy "$opt"; shift; break ;;
        -*)           func_fatal_help "unrecognised option: \`$opt'" ;;
        *)            set dummy "$opt"; shift; break ;;
      esac
    done

    # save modified positional parameters for caller
    func_quote_for_eval ${1+"$@"}
    func_parse_options_result="$func_quote_for_eval_result"
}


# func_validate_options [ARG]...
# ------------------------------
# Perform any sanity checks on option settings and/or unconsumed
# arguments.
func_hookable func_validate_options
func_validate_options ()
{
    $debug_cmd

    # display all warnings if -W was not given
    test -n "$opt_warning" || opt_warning="$warning_categories"

    func_run_hooks func_validate_options ${1+"$@"}

    # Validate options.
    test $# -gt 0 \
        && func_fatal_help "too many arguments"

    # Bail if the options were screwed!
    $exit_cmd $EXIT_FAILURE

    # save modified positional parameters for caller
    func_quote_for_eval ${1+"$@"}
    func_validate_options_result="$func_quote_for_eval_result"
}


# func_prep
# ---------
# Function to perform preparation for remaining bootstrap process. If
# your hooked code relies on the outcome of `func_options' hook it here
# rather than to `func_init'.
#
# All the functions called inside func_prep are hookable. See the
# individual implementations for details.
func_hookable func_prep
func_prep ()
{
    $debug_cmd

    $require_bootstrap_uptodate
    $require_buildtools_uptodate
    $require_checkout_only_file

    $require_gnulib_merge_changelog

    # fetch update files from the translation project
    func_update_translations

    func_run_hooks func_prep
}


# func_update_translations
# ------------------------
# Update package po files and translations.
func_hookable func_update_translations
func_update_translations ()
{
    $debug_cmd

    $opt_skip_po || {
      test -d po && {
        $require_package

        func_update_po_files po $package || exit $?
      }

      func_run_hooks func_update_translations
    }
}


# func_reconfigure
# ----------------
# Reconfigure the current package by running the appropriate autotools in a
# suitable order.
func_hookable func_reconfigure
func_reconfigure ()
{
    $debug_cmd

    # Released `autopoint' has the tendency to install macros that have
    # been obsoleted in current `gnulib., so run this before `gnulib-tool'.
    func_autopoint

    # Autoreconf runs `aclocal' before `libtoolize', which causes spurious
    # warnings if the initial `aclocal' is confused by the libtoolized
    # (or worse: out-of-date) macro directory.
    func_libtoolize

    # If you need to do anything after `gnulib-tool' is done, but before
    # `autoreconf' runs, you don't need to override this whole function,
    # because `func_gnulib_tool' is hookable.
    func_gnulib_tool

    func_autoreconf

    func_run_hooks func_reconfigure
}


# func_gnulib_tool
# ----------------
# Run `gnulib-tool' to fetch gnulib modules into the current package.
#
# It's assumed that since you are using gnulib's `bootstrap' script,
# you're also using gnulib elsewhere in your package.  If not, then
# you can replace this function in `bootstrap.conf' with:
#
#   func_gnulib_tool () { :; }
#
# (although the function returns immediately if $gnulib_tool is set to
# true in any case).
func_hookable func_gnulib_tool
func_gnulib_tool ()
{
    $debug_cmd

    $require_gnulib_tool
    $require_libtoolize

    test true = "$gnulib_tool" || {
      if test -n "$gnulib_modules"; then
        $require_gnulib_cache
        $require_build_aux
        $require_macro_dir

        # Try not to pick up any stale values from `gnulib-cache.m4'.
        rm -f "$gnulib_cache"

        gnulib_mode="--import"

        # `gnulib_modules' and others are maintained in `bootstrap.conf`:
        # Use `gnulib --import` to fetch gnulib modules.
        test -n "$build_aux" \
            && func_append_u gnulib_tool_options " --aux-dir=$build_aux"
        test -n "$macro_dir" \
            && func_append_u gnulib_tool_options " --m4-base=$macro_dir"
        test -n "$doc_base" \
            && func_append_u gnulib_tool_options " --doc-base=$doc_base"
        test -n "$gnulib_name" \
            && func_append_u gnulib_tool_options " --lib=$gnulib_name"
        test -n "$local_gl_dir" \
            && func_append_u gnulib_tool_options " --local-dir=$local_gl_dir"
        test -n "$source_base" \
            && func_append_u gnulib_tool_options " --source-base=$source_base"
        test -n "$gnulib_mk" \
            && func_append_u gnulib_tool_options " --makefile-name=$gnulib_mk"
        test -n "$tests_base" && {
          func_append_u gnulib_tool_options " --tests-base=$tests_base"
          func_append_u gnulib_tool_options " --with-tests"
        }
      else

        # `gnulib_modules' and others are cached in `gnulib-cache.m4':
        # Use `gnulib --update' to fetch gnulib modules.
        gnulib_mode="--update"
      fi

      # Add a sensible default libtool option to gnulib_tool_options.
      # The embedded echo is to squash whitespace before globbing.
      case `echo " "$gnulib_tool_options" "` in
        *" --no-libtool "*|*" --libtool "*) ;;
        *)  if test true = "$LIBTOOLIZE"; then
              func_append_u gnulib_tool_options " --no-libtool"
            else
              func_append_u gnulib_tool_options " --libtool"
            fi
            ;;
      esac

      $opt_copy || func_append_u gnulib_tool_options " --symlink"

      func_append_u gnulib_tool_options " $gnulib_mode"
      func_append gnulib_tool_options " $gnulib_modules"

      # The embedded echo is to squash whitespace before display.
      gnulib_cmd=`echo $gnulib_tool $gnulib_tool_options`

      func_show_eval "$gnulib_cmd" 'exit $?'
    }

    # Use `gnulib-tool --copy-file' to install non-module files.
    func_install_gnulib_non_module_files

    func_run_hooks func_gnulib_tool
}


# func_fini
# ---------
# Function to perform all finalisation for the bootstrap process.
func_hookable func_fini
func_fini ()
{
    $debug_cmd

    func_gettext_configuration
    func_clean_dangling_symlinks
    func_clean_unused_macros
    func_skip_po_recommendation

    func_run_hooks func_fini

    func_echo "Done.  Now you can run './configure'."
}


# func_gettext_configuration
# --------------------------
# Edit configuration values into po/Makevars.
func_hookable func_gettext_configuration
func_gettext_configuration ()
{
    $debug_cmd

    $require_autopoint

    test true = "$AUTOPOINT" || {
      $require_copyright_holder
      $require_extra_locale_categories
      $require_package_bugreport

      # Escape xgettext options for sed Makevars generation below.
      # We have to delete blank lines in a separate script so that we don't
      # append \\\ to the penultimate line, and then delete the last empty
      # line, which messes up the variable substitution later in this
      # function.  Note that adding a literal \\\ requires double escaping
      # here, once for the execution subshell, and again for the assignment,
      # which is why there are actually 12 (!!) backslashes in the script.
      my_xgettext_options=`echo "$xgettext_options$nl" |$SED '/^$/d' |$SED '
          $b
          s|$| \\\\\\\\\\\\|'`

      # Create gettext configuration.
      func_echo "Creating po/Makevars from po/Makevars.template ..."
      $RM -f po/Makevars
      $SED '
        /^EXTRA_LOCALE_CATEGORIES *=/s|=.*|= '"$extra_locale_categories"'|
        /^COPYRIGHT_HOLDER *=/s|=.*|= '"$copyright_holder"'|
        /^MSGID_BUGS_ADDRESS *=/s|=.*|= '"$package_bugreport"'|
        /^XGETTEXT_OPTIONS *=/{
          s|$| \\|
          a\
             '"$my_xgettext_options"' \\\
             $${end_of_xgettext_options+}
        }
      ' po/Makevars.template >po/Makevars || exit 1
    }

    func_run_hooks func_gettext_configuration
}



## --------------- ##
## Core functions. ##
## --------------- ##

# This section contains the main functions called from the `Hookable
# functions' (shown above), and are the ones you're  most likely
# to want to replace with your own implementations in `bootstrap.conf'.


# func_autopoint
# --------------
# If this package uses gettext, then run `autopoint'.
func_autopoint ()
{
    $debug_cmd

    $require_autopoint

    test true = "$AUTOPOINT" \
        || func_show_eval "$AUTOPOINT --force" 'exit $?'
}


# func_libtoolize
# ---------------
# If this package uses libtool, then run `libtoolize'.
func_libtoolize ()
{
    $debug_cmd

    $require_libtoolize

    test true = "$LIBTOOLIZE" || {
      my_libtoolize_options=
      $opt_copy && func_append my_libtoolize_options " --copy"
      $opt_force && func_append my_libtoolize_options " --force"
      $opt_verbose || func_append my_libtoolize_options " --quiet"
      func_show_eval "$LIBTOOLIZE$my_libtoolize_options" 'exit $?'
    }
}


# func_gnulib_tool_copy_file SRC DEST
# -----------------------------------
# Copy SRC, a path relative to the gnulib sub-tree, to DEST, a path
# relative to the top-level source directory using gnulib-tool so that
# any patches or replacements in $local_gl_dir are applied.
func_gnulib_tool_copy_file ()
{
    $debug_cmd

    $require_gnulib_path
    $require_gnulib_tool

    gnulib_copy_cmd="$gnulib_tool --copy-file"
    $opt_copy || func_append gnulib_copy_cmd " --symlink"

    if test true = "$gnulib_tool"; then
      # If gnulib-tool is not available (e.g. bootstrapping in a
      # distribution tarball), make sure that at least we have some
      # version of the required file already in place.
      test -f "$2" || func_fatal_error "\
error: Can't find, copy or download \`$2', a required
       gnulib supplied file, please provide the location of a
       complete \`gnulib' tree by setting \`gnulib_path' in your
       \`bootstrap.conf' or with the \`--gnulib-srcdir' option -
       or else specify the location of your \`git' binary by
       setting \`GIT' in the environment so that a fresh
       \`gnulib' submodule can be cloned."
    else
      test -f "$gnulib_path/$1" || {
        func_error "error: \`$gnulib_path/$1' does not exist"
        return 1
      }

      $gnulib_copy_cmd $1 $2
    fi
}


# func_install_gnulib_non_module_files
# ------------------------------------
# Get additional non-module files from gnulib, overriding existing files.
func_install_gnulib_non_module_files ()
{
    $debug_cmd

    $require_build_aux
    $require_gnulib_tool

    test -n "$gnulib_non_module_files" && {
      maybe_exit_cmd=:

      for file in $gnulib_non_module_files; do
        case $file in
          */COPYING*) dest=COPYING;;
          */INSTALL) dest=INSTALL;;
          build-aux/*) dest=$build_aux/`expr "$file" : 'build-aux/\(.*\)'`;;
          *) dest=$file;;
        esac

        # Be sure to show all copying errors before bailing out
	func_gnulib_tool_copy_file "$file" "$dest" \
	    || maybe_exit_cmd="exit $EXIT_FAILURE"
      done

      $maybe_exit_cmd
    }
}


# func_ensure_changelog
# ---------------------
# Even with 'gitlog-to-changelog' generated ChangeLogs, automake
# will not run to completion with no ChangeLog file.
func_ensure_changelog ()
{
    $debug_cmd

    test -f ChangeLog && mv -f ChangeLog ChangeLog~

    cat >ChangeLog <<'EOT'
## ---------------------- ##
## DO NOT EDIT THIS FILE! ##
## ---------------------- ##

ChangeLog is generated by gitlog-to-changelog.
EOT

    my_message="creating dummy \`ChangeLog'"
    test -f ChangeLog~ \
      && func_append my_message ' (backup in ChangeLog~)'
    func_verbose "$my_message"

    return 0
}


# func_autoreconf
# ---------------
# Being careful not to re-run `autopoint' or `libtoolize', and not to
# try to run `autopoint', `libtoolize' or `autoheader' on packages that
# don't use them, defer to `autoreconf' for execution of the remaining
# autotools to bootstrap this package.
func_autoreconf ()
{
    $debug_cmd

    $require_autoheader
    $require_build_aux  # automake and others put files in here
    $require_macro_dir  # aclocal and others put files in here

    # We ran these manually already, and autoreconf won't exec `:'
    save_AUTOPOINT="$AUTOPOINT"; AUTOPOINT=true
    save_LIBTOOLIZE="$LIBTOOLIZE"; LIBTOOLIZE=true

    my_autoreconf_options=
    $opt_copy || func_append my_autoreconf_options " --symlink"
    $opt_force && func_append my_autoreconf_options " --force"
    $opt_verbose && func_append my_autoreconf_options " --verbose"
    func_show_eval "$AUTORECONF$my_autoreconf_options --install" 'exit $?'

    AUTOPOINT="$save_AUTOPOINT"
    LIBTOOLIZE="$save_LIBTOOLIZE"
}


# func_check_configuration VARNAME [CONFIGURE_MACRO]
# --------------------------------------------------
func_check_configuration ()
{
    $debug_cmd

    $require_configure_ac

    eval 'test -n "$'$1'"' || {
      my_error_msg="error: please set \`$1' in \`bootstrap.conf'"
      test -n "$2" \
          && func_append my_error_msg "
       or add the following (or similar) to your \`$configure_ac':
       $2"

      func_fatal_error "$my_error_msg"
    }
}


# func_clean_dangling_symlinks
# ----------------------------
# Remove any dangling symlink matching "*.m4" or "*.[ch]" in some
# gnulib-populated directories. Such .m4 files would cause aclocal to
# fail.  The following requires GNU find 4.2.3 or newer. Considering
# the usual portability constraints of this script, that may seem a very
# demanding requirement, but it should be ok.  Ignore any failure,
# which is fine, since this is only a convenience to help developers
# avoid the relatively unusual case in which a symlinked-to .m4 file is
# git-removed from gnulib between successive runs of this script.
func_clean_dangling_symlinks ()
{
    $debug_cmd

    $require_macro_dir
    $require_source_base

    func_verbose "cleaning dangling symlinks"

    find "$macro_dir" "$source_base" \
        -depth \( -name '*.m4' -o -name '*.[ch]' \) \
        -type l -xtype l -delete > /dev/null 2>&1
}


# func_clean_unused_macros
# ------------------------
# Autopoint can result in over-zealously adding macros into $macro_dir
# even though they are not actually used, for example tests to help
# build the `intl' directory even though you have specified
# `AM_GNU_GETTEXT([external])' in your configure.ac.  This function
# looks removes any macro files that can be found in gnulib,  but
# are not `m4_include'd by `aclocal.m4'.
func_clean_unused_macros ()
{
    $debug_cmd

    $require_gnulib_path
    $require_macro_dir

    test -n "$gnulib_path" && test -f aclocal.m4 && {
      aclocal_m4s=`find . -name aclocal.m4 -print`

      # We use `ls|grep' instead of `ls *.m4' to avoid exceeding
      # command line length limits in some shells.
      for file in `cd $macro_dir && ls -1 |grep '\.m4$'`; do

	# Remove a macro file when aclocal.m4 does not m4_include it...
        func_grep_q 'm4_include([[]'$macro_dir/$file'])' $aclocal_m4s \
            || test ! -f $gnulib_path/m4/$file || {

              # ...and there is an identical file in gnulib...
              if func_cmp_s $gnulib_path/m4/$file $macro_dir/$file; then

                # ...and it's not in the precious list (`echo' is needed
                # here to squash whitespace for the match expression).
                case " "`echo $gnulib_precious`" " in
                  *" $file "*) ;;
                  *) rm -f $macro_dir/$file
                     func_verbose \
                       "removing unused gnulib file \`$macro_dir/$file'"
                esac
              fi
        }
      done
    }
}


# func_skip_po_recommendation
# ---------------------------
# If there is a po directory, and `--skip-po' wasn't passed, let the
# user know that they can use `--skip-po' on subsequent invocations.
func_skip_po_recommendation ()
{
    $debug_cmd

    test ! -d po \
        || $opt_skip_po \
        || func_warning recommend "\
If your pofiles are up-to-date, you can rerun bootstrap
as \`$progname --skip-po' to avoid redownloading."
}


# func_update_dotversion
# ----------------------
# Even with 'gitlog-to-changelog' generated ChangeLogs, automake
# will not run to completion with no ChangeLog file.
func_update_dotversion ()
{
    $debug_cmd

    test -f "$build_aux/git-version-gen" && {
      my_message="updating .version"
      test -f .version && {
        mv .version .version~
	func_append my_message " (backup in .version~)"
      }
      func_verbose "updating .version"

      $build_aux/git-version-gen dummy-arg > .version
    }
}



## -------------------- ##
## 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.  Where a variable already has a non-
# empty value (as set by the package's `bootstrap.conf'), that value is
# used in preference to deriving the default. Call them using their
# associated `require_*' variable to ensure that they are executed, at
# most, once.


# require_checkout_only_file
# --------------------------
# Bail out  if this package only bootstraps properly from a repository
# checkout.
require_checkout_only_file=func_require_checkout_only_file
func_require_checkout_only_file ()
{
    $debug_cmd

    $opt_force || {
      test -n "$checkout_only_file" && test ! -f "$checkout_only_file" \
          && func_fatal_error "\
error: Bootstrapping from a non-checked-out distribution is risky.
       If you wish to bootstrap anyway, use the \`--force' option."
    }

    require_checkout_only_file=:
}


# require_aclocal_amflags
# -----------------------
# Ensure `$aclocal_amflags' has a sensible default, extracted from
# `Makefile.am' if necessary.
require_aclocal_amflags=func_require_aclocal_amflags
func_require_aclocal_amflags ()
{
    $debug_cmd

    $require_makefile_am

    my_sed_extract_aclocal_amflags='s|#.*$||
        /^[	 ]*ACLOCAL_AMFLAGS[	 ]*=/ {
            s|^.*=[	 ]*\(.*\)|aclocal_amflags="\1"|
            p
        }'

    my_aclocal_flags_cmd=`$SED -n "$my_sed_extract_aclocal_amflags" \
        "$makefile_am"`
    eval "$my_aclocal_flags_cmd"

    func_verbose "ACLOCAL_AMFLAGS='$aclocal_amflags'"

    require_aclocal_amflags=:
}


# require_autobuild_buildreq
# --------------------------
# Try to find whether the bootstrap requires autobuild.
require_autobuild_buildreq=func_require_autobuild_buildreq
func_require_autobuild_buildreq ()
{
    $debug_cmd

    $require_macro_dir

    test -f "$macro_dir/autobuild.m4" \
        || printf '%s\n' "$buildreq" |func_grep_q '^[	 ]*autobuild' \
        || {
      $require_configure_ac

      func_extract_trace AB_INIT
      test -n "$func_extract_trace_result" && {
        func_append buildreq 'autobuild - http://josefsson.org/autobuild/
'
        func_verbose "auto-adding \`autobuild' to build requirements"
      }
    }

    require_autobuild_buildreq=:
}


# require_autoconf_buildreq
# require_autopoint_buildreq
# require_libtoolize_buildreq
# ---------------------------
# Try to find the minimum compatible version of autoconf/libtool
# required to bootstrap successfully, and add it to `$buildreq'.
for tool in autoconf libtoolize autopoint; do
  b=$tool
  v=require_${tool}_buildreq
  f=func_$v
  case $tool in
    autoconf) m=AC_PREREQ ;;
    libtoolize) m=LT_PREREQ; b=libtool ;;
    autopoint) m=AM_GNU_GETTEXT_VERSION b=gettext ;;
  esac

  eval $v'='$f'
  '$f' ()
  {
    $debug_cmd

    # The following is ignored if undefined, but might be necessary
    # in order for `func_find_tool` to run.
    ${require_'$tool'-:}

    printf '%s\n' "$buildreq" |func_grep_q '\''^[	 ]*'$tool\'' || {
      $require_configure_ac

      func_extract_trace '$m'
      my_version="$func_extract_trace_result"
      test -n "$my_version" && {
        func_append buildreq "\
            '$tool' $my_version http://www.gnu.org/s/'$b'
"
        func_verbose \
            "auto-adding \`'$tool'-$my_version'\'' to build requirements"
      }
    }

    '$v'=:
  }
'
done


# require_autoheader
# ------------------
# Skip autoheader if it's not needed.
require_autoheader=func_require_autoheader
func_require_autoheader ()
{
    $debug_cmd

    test true = "$AUTOHEADER" || {
      func_extract_trace AC_CONFIG_HEADERS
      test -n "$func_extract_trace_result" \
	  || func_extract_trace AC_CONFIG_HEADER

      test -n "$func_extract_trace_result" || {
        AUTOHEADER=true

        func_verbose "export AUTOHEADER='$AUTOHEADER'"

        # Make sure the search result is visible to subshells
        export AUTOHEADER
      }
    }

    require_autoheader=:
}


# require_automake_buildreq
# -------------------------
# Try to find the minimum compatible version of automake required to
# bootstrap successfully, and add it to `$buildreq'.
require_automake_buildreq=func_require_automake_buildreq
func_require_automake_buildreq ()
{
    $debug_cmd

    # if automake is not already listed in $buildreq...
    printf '%s\n' "$buildreq" |func_grep_q automake || {
      func_extract_trace AM_INIT_AUTOMAKE

      # ...and AM_INIT_AUTOMAKE is declared...
      test -n "$func_extract_trace_result" && {
        automake_version=`echo "$func_extract_trace_result" \
           |$SED 's|[^0-9]*||; s| .*$||'`
        test -n "$automake_version" || automake_version="-"

        func_append buildreq "\
            automake $automake_version http://www.gnu.org/s/automake
"
        func_verbose \
            "auto-adding \`automake-$automake_version' to build requirements"
      }
    }

    require_automake_buildreq=:
}


# require_autopoint
# -----------------
# Skip autopoint if it's not needed.
require_autopoint=func_require_autopoint
func_require_autopoint ()
{
    $debug_cmd

    test true = "$AUTOPOINT" || {
      func_extract_trace AM_GNU_GETTEXT_VERSION

      test -n "$func_extract_trace_result" || {
        AUTOPOINT=true

        func_verbose "export AUTOPOINT='$AUTOPOINT'"

        # Make sure the search result is visible to subshells
        export AUTOPOINT
      }
    }

    require_autopoint=:
}


# func_require_bootstrap_uptodate
# -------------------------------
# Complain if the version of bootstrap in the gnulib directory differs
# from the one we are running.
require_bootstrap_uptodate=func_require_bootstrap_uptodate
func_require_bootstrap_uptodate ()
{
    $debug_cmd

    $require_gnulib_path

    test x = x"$gnulib_path" \
        || func_cmp_s $progpath $gnulib_path/build-aux/bootstrap \
        || func_warning upgrade "\
\`$progpath' differs from \`./$gnulib_path/build-aux/bootstrap',
please consider adopting the canonical version from gnulib."

    require_bootstrap_uptodate=:
}


# require_build_aux
# -----------------
# Ensure that `$build_aux' is set, and if it doesn't already point to an
# existing directory, create one.
require_build_aux=func_require_build_aux
func_require_build_aux ()
{
    $debug_cmd

    test -n "$build_aux" || {
      $require_configure_ac

      func_extract_trace AC_CONFIG_AUX_DIR
      build_aux="$func_extract_trace_result"
      func_check_configuration build_aux \
          "AC_CONFIG_AUX_DIR([name of a directory for build scripts])"

      func_verbose "build_aux='$build_aux'"
    }

    $require_vc_ignore_files

    # If the build_aux directory doesn't exist, create it now, and mark it
    # as ignored for the VCS.
    if test ! -d "$build_aux"; then
      func_show_eval "mkdir '$build_aux'"

      test -n "$vc_ignore_files" \
          || func_insert_sorted_if_absent "$build_aux" $vc_ignore_files
    fi

    require_build_aux=:
}


# func_require_buildtools_uptodate
# --------------------------------
# Ensure all the packages listed in BUILDREQS are available on the build
# machine at the minimum versions or better.
require_buildtools_uptodate=func_require_buildtools_uptodate
func_require_buildtools_uptodate ()
{
    $debug_cmd

    $require_autobuild_buildreq
    $require_autoconf_buildreq
    $require_automake_buildreq
    $require_libtoolize_buildreq
    $require_autopoint_buildreq

    test -n "$buildreq" && {
      func_check_versions $buildreq
      $func_check_versions_result || {
        test -n "$buildreq_readme" \
            && test -f "$buildreq_readme" \
            && func_error "\
error: $buildreq_readme explains how to obtain these prerequisite programs:
"
        func_strtable 7 11 12 36 \
            "Program" "Min_version" "Homepage" $buildreq
        func_fatal_error "$func_strtable_result"
      }
    }

    require_buildtools_uptodate=:
}


# require_configure_ac
# --------------------
# Ensure that there is a `configure.ac' or `configure.in' file in the
# current directory, and that `$configure_ac' contains its name.
require_configure_ac=func_require_configure_ac
func_require_configure_ac ()
{
    $debug_cmd

    test -n "$configure_ac" || {
      for configure_ac in configure.ac configure.in; do
        test -f $configure_ac && break
      done

      <$configure_ac
    }

    func_verbose "found \`$configure_ac'"

    require_configure_ac=:
}


# require_copyright_holder
# ------------------------
# Ensure there is a sensible non-empty default value in `$copyright_holder'.
require_copyright_holder=func_require_copyright_holder
func_require_copyright_holder ()
{
    $debug_cmd

    test -n "$copyright_holder" || {
      copyright_holder='Free Software Foundation, Inc.'
      func_warning settings "\
Please set copyright_holder explicitly in \`bootstrap.conf';
defaulting to \`$copyright_holder'."
    }

    require_copyright_holder=:
}


# require_dotgitmodules
# ---------------------
# Ensure we have a `.gitmodules' file, with appropriate `gnulib' settings.
require_dotgitmodules=func_require_dotgitmodules
func_require_dotgitmodules ()
{
    $debug_cmd

    $require_git

    test true = "$GIT" || {
      # A gnulib entry in .gitmodules always takes precedence.
      my_path="`$GIT config --file .gitmodules submodule.gnulib.path 2>/dev/null`"

      test -n "$my_path" || {
        $require_vc_ignore_files

        func_verbose "creating \`.gitmodules'"

        # If the .gitmodules file doesn't exist, create it now, and mark
        # it as ignored for the VCS.
        test -n "$gnulib_path" || gnulib_path=gnulib
        test -n "$gnulib_url"  || gnulib_url=git://git.sv.gnu.org/gnulib

        {
          echo '[submodule "gnulib"]'
          echo "	path = $gnulib_path"
          echo "	url = $gnulib_url"
        } >> .gitmodules

        test -n "$vc_ignore_files" \
          || func_insert_sorted_if_absent ".gitmodules" $vc_ignore_files
      }
    }

    require_dotgitmodules=:
}


# require_extra_locale_categories
# -------------------------------
# Ensure there is a default value in `$extra_locale_categories'
require_extra_locale_categories=func_require_extra_locale_categories
func_require_extra_locale_categories ()
{
    $debug_cmd

    # Defaults to empty, so run with whatever value may have been set in
    # `bootstrap.conf'.
    require_extra_locale_categories=:
}


# require_git
# -----------
# Ignore git if it's not available, or we're not in a git checkout tree.
require_git=func_require_git
func_require_git ()
{
    $debug_cmd

    $opt_skip_git && GIT=true

    test true = "$GIT" || {
      if test -f .gitignore && ($GIT --version) >/dev/null 2>&1; then :; else
      GIT=true
      fi
    }

    func_verbose "GIT='$GIT'"

    require_git=:
}


# require_gnu_m4
# --------------
# Search for GNU M4, and export it in $M4.
require_gnu_m4=func_require_gnu_m4
func_require_gnu_m4 ()
{
    $debug_cmd

    test -n "$M4" || {
      # Find the first m4 binary that responds to --version.
      func_find_tool M4 gm4 gnum4 m4
    }

    test -n "$M4" || func_fatal_error "\
error: Please install GNU M4, or \`export M4=/path/to/gnu/m4'."

    func_verbose "export M4='$M4'"

    # Make sure the search result is visible to subshells
    export M4

    require_gnu_m4=:
}


# require_gnulib_cache
# --------------------
# Ensure there is a non-empty default for `$gnulib_cache', and that it
# names an existing file.
require_gnulib_cache=func_require_gnulib_cache
func_require_gnulib_cache ()
{
    $debug_cmd

    $require_macro_dir

    test -n "$gnulib_cache" \
      || gnulib_cache="$macro_dir/gnulib-cache.m4"

    func_verbose "found \`$gnulib_cache'"

    require_gnulib_cache=:
}


# require_gnulib_merge_changelog
# ------------------------------
# See if we can use gnulib's git-merge-changelog merge driver.
require_gnulib_merge_changelog=func_require_gnulib_merge_changelog
func_require_gnulib_merge_changelog ()
{
    $debug_cmd

    test -f ChangeLog && {
      $require_git

      test true = "$GIT" || {
        if $GIT config merge.merge-changelog.driver >/dev/null ; then
          :
        elif (git-merge-changelog --version) >/dev/null 2>&1 ; then
          func_echo "initializing git-merge-changelog driver"
          $GIT config merge.merge-changelog.name 'GNU-style ChangeLog merge driver'
          $GIT config merge.merge-changelog.driver 'git-merge-changelog %O %A %B'
        else
          func_warning recommend \
              "Consider installing git-merge-changelog from gnulib."
        fi
      }
    }

    require_gnulib_merge_changelog=:
}


# require_gnulib_mk
# -----------------
# Ensure gnulib_mk has a sensible value, extracted from `gnulib-cache.m4'
# if possible, otherwise letting `gnulib-tool' pick a default.
require_gnulib_mk=func_require_gnulib_mk
func_require_gnulib_mk ()
{
    $debug_cmd

    test -f "$gnulib_cache" && test -z "$gnulib_mk" && {
      $require_gnulib_cache
      $require_macro_dir

      func_extract_trace "gl_MAKEFILE_NAME" "$gnulib_cache"
      gnulib_mk="$func_extract_trace_result"

      test -n "$gnulib_mk" && func_verbose "gnulib_mk='$gnulib_mk'"
    }

    require_gnulib_mk=:
}


# require_gnulib_path
# require_gnulib_url
# -------------------
# Ensure `gnulib_path' and `gnulib_url' are set.
require_gnulib_path=func_require_dotgitmodules_parameters
require_gnulib_url=func_require_dotgitmodules_parameters
func_require_dotgitmodules_parameters ()
{
    $debug_cmd

    $require_git

    test true = "$GIT" && {
      # If we can't find git (or if the user specified `--skip-git'),
      # then use an existing gnulib directory specified with
      # `--gnulib-srcdir' if possible.
      test -n "$gnulib_path" \
          || test ! -x "$opt_gnulib_srcdir/gnulib-tool" \
          || gnulib_path="$opt_gnulib_srcdir"
    }


    $require_dotgitmodules

    test -f .gitmodules && {
      # Extract the parameters with sed, since git may be missing
      test -n "$gnulib_path" \
        || gnulib_path=`$SED -e '/^.submodule "gnulib".$/,${
                                   /[	 ]*path *= */{
			             s,[   ]*,,g;s,^[^=]*=,,;p
			           }
		                 };d' .gitmodules |$SED 1q`
      test -n "$gnulib_url" \
        || gnulib_url=`$SED -e '/^.submodule "gnulib".$/,${
                                  /[	 ]*url *= */{
			            s,[   ]*,,g;s,^[^=]*=,,;p
			          }
		                };d' .gitmodules |$SED 1q`

      func_verbose "gnulib_path='$gnulib_path'"
      func_verbose "gnulib_url='$gnulib_url'"
    }

    require_gnulib_path=:
    require_gnulib_url=:
}


# require_gnulib_submodule
# ------------------------
# Ensure that there is a current gnulib submodule at `$gnulib_path'.
require_gnulib_submodule=func_require_gnulib_submodule
func_require_gnulib_submodule ()
{
    $debug_cmd

    $require_git

    if test true = "$GIT"; then
      func_warning recommend \
          "No \`git' found; imported gnulib modules may be outdated."
    else
      $require_gnulib_path
      $require_gnulib_url

      if test -f .gitmodules && test -f "$gnulib_path/gnulib-tool"; then
        func_show_eval "$GIT submodule update" \
            'func_fatal_error "error: Unable to update gnulib submodule."'

      elif test -n "$opt_gnulib_srcdir"; then
        # Older git can't clone into an empty directory.
        rmdir "$gnulib_path" 2>/dev/null
        func_show_eval "$GIT clone --reference '$opt_gnulib_srcdir' \
                '$gnulib_url' '$gnulib_path'" \
            && func_show_eval "$GIT submodule init" \
            && func_show_eval "$GIT submodule update" \
            || func_fatal_error "error: Unable to fetch gnulib submodule."

      # Without --gnulib-srcdir, and no existing checked out submodule, we
      # create a new shallow clone of the remote gnulib repository.
      else
        trap func_cleanup_gnulib 1 2 13 15

        shallow=
        $GIT clone -h 2>&1 |func_grep_q -- --depth \
            && shallow='--depth 2'

        func_show_eval "$GIT clone $shallow '$gnulib_url' '$gnulib_path'" \
          func_cleanup_gnulib

	# FIXME: Solaris /bin/sh will try to execute '-' if any of
	#        these signals are caught after this.
        trap - 1 2 13 15
      fi
    fi

    require_gnulib_submodule=:
}


# require_gnulib_tool
# -------------------
# Ensure that `$gnulib_tool' is set, and points to an executable file,
# or else fall back to using the binary `true' if the main gnulib
# files appear to have been imported already.
require_gnulib_tool=func_require_gnulib_tool
func_require_gnulib_tool ()
{
    $debug_cmd

    $require_gnulib_submodule

    test true = "$gnulib_tool" || {
      $require_gnulib_path

      test -n "$gnulib_tool" \
        || gnulib_tool="$gnulib_path/gnulib-tool"

      test -x "$gnulib_tool" || {
        gnulib_tool=true
        func_warning recommend \
            "No \`gnulib-tool' found; gnulib modules may be missing."
      }

      test true = "$gnulib_tool" \
          || func_verbose "found \`$gnulib_tool'"
    }

    require_gnulib_tool=:
}


# require_libtoolize
# ------------------
# Skip libtoolize if it's not needed.
require_libtoolize=func_require_libtoolize
func_require_libtoolize ()
{
    $debug_cmd

    # Unless we're not searching for libtool use by this package, set
    # LIBTOOLIZE to true if none of `LT_INIT', `AC_PROG_LIBTOOL' and
    # `AM_PROG_LIBTOOL' are used in configure.
    test true = "$LIBTOOLIZE" || {
      func_extract_trace LT_INIT
      test -n "$func_extract_trace_result" || func_extract_trace AC_PROG_LIBTOOL
      test -n "$func_extract_trace_result" || func_extract_trace AM_PROG_LIBTOOL
      test -n "$func_extract_trace_result" || LIBTOOLIZE=true
    }

    test -n "$LIBTOOLIZE" || {
      # Find libtoolize, named glibtoolize in Mac Ports, but prefer
      # user-installed libtoolize to ancient glibtoolize shipped by
      # Apple with Mac OS X when Mac Ports is not installed.
      func_find_tool LIBTOOLIZE libtoolize glibtoolize
    }

    func_verbose "export LIBTOOLIZE='$LIBTOOLIZE'"

    # Make sure the search result is visible to subshells
    export LIBTOOLIZE

    require_libtoolize=:
}


# require_macro_dir
# -----------------
# Ensure that `$macro_dir' is set, and if it doesn't already point to an
# existing directory, create one.
require_macro_dir=func_require_macro_dir
func_require_macro_dir ()
{
    $debug_cmd

    # Sometimes this is stored in `configure.ac'.
    test -n "$macro_dir" || {
      func_extract_trace AC_CONFIG_MACRO_DIR
      macro_dir="$func_extract_trace_result"
    }

    # Otherwise we might find it in `Makefile.am'.
    test -n "$macro_dir" || {
      $require_aclocal_amflags

      my_sed_scan='s|^.*-I[	 ]*\([^	 ]*\) .*|\1|'

      # Trailing space in echo is required by the sed script.
      macro_dir=`echo "$aclocal_amflags " |$SED "$my_sed_scan"`
    }

    func_verbose "macro_dir='$macro_dir'"

    func_check_configuration macro_dir \
        "AC_CONFIG_MACRO_DIR([name of a directory for configure m4 files])"

    $require_vc_ignore_files

    # If the macro_dir directory doesn't exist, create it now, and mark it
    # as ignored for the VCS.
    if test ! -d "$macro_dir"; then
      mkdir "$macro_dir" || func_permissions_error "$macro_dir"

      test -n "$vc_ignore_files" \
        || func_insert_sorted_if_absent "$macro_dir" $vc_ignore_files
    fi

    require_macro_dir=:
}


# require_makefile_am
# -------------------
# Ensure there is a `Makefile.am' in the current directory.
# names an existing file.
require_makefile_am=func_require_makefile_am
func_require_makefile_am ()
{
    $debug_cmd

    test -n "$makefile_am" \
      || makefile_am="Makefile.am"

    <"$makefile_am"

    func_verbose "found \`$makefile_am'"

    require_makefile_am=:
}


# require_package
# ---------------
# Ensure that `$package' contains a sensible default value.
require_package=func_require_package
func_require_package ()
{
    $debug_cmd

    test -n "$package" || {
      $require_package_name

      package=`echo "$package_name" \
        |$SED 's/GNU //;y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'`
    }

    func_verbose "package='$package'"

    require_package=:
}


# require_package_bugreport
# -------------------------
# Ensure that this has a sensible value, extracted from `configure.ac'
# if appropriate (and possible!).
require_package_bugreport=func_require_package_bugreport
func_require_package_bugreport ()
{
    $debug_cmd

    func_extract_trace AC_INIT

    save_ifs="$IFS"
    IFS=:
    set dummy $func_extract_trace_result
    IFS="$save_ifs"
    shift

    test -n "$package_bugreport" || package_bugreport="$3"
    func_check_configuration package_bugreport \
      "AC_INIT([$package_name], [$package_version], [bug-$package@gnu.org])"
    func_verbose "package_bugreport='$package_bugreport'"

    require_package_bugreport=:
}


# require_package_name
# --------------------
# Ensure that this has a sensible value, extracted from `configure.ac'
# if appropriate (and possible!).
require_package_name=func_require_package_name
func_require_package_name ()
{
    $debug_cmd

    func_extract_trace AC_INIT

    save_ifs="$IFS"
    IFS=:
    set dummy $func_extract_trace_result
    IFS="$save_ifs"
    shift

    test -n "$package_name" || package_name="$1"
    func_check_configuration package_name \
      "AC_INIT([name of your package], [package version number])"
    func_verbose "package_name='$package_name'"

    require_package_name=:
}


# require_package_version
# -----------------------
# Ensure that this has a sensible value, extracted from `configure.ac'
# if appropriate (and possible!).  While we might have set all the
# parameters extracted from AC_INIT at once, `package_version' in
# particular is not necessarily available as early as the others, since
# `git-version-gen' is often involved, and until then we can't rely on
# getting a correct version number from an AC_INIT extraction.
require_package_version=func_require_package_version
func_require_package_version ()
{
    $debug_cmd

    func_extract_trace AC_INIT

    save_ifs="$IFS"
    IFS=:
    set dummy $func_extract_trace_result
    IFS="$save_ifs"
    shift

    test -n "$package_version" || package_version="$2"
    test -n "$package_version" || {
      # The embedded echo is to squash whitespace before globbing.
      case " "`echo $gnulib_modules`" " in
	*" git-version-gen "*)
	  func_fatal_error "\
error: cannot \$require_package_version in bootstrap.conf before
       func_gnulib_tool has installed the \`git-version-gen' script."
	  ;;
	*)
          func_check_configuration package_version \
            "AC_INIT([name of your package], [package version number])"
	  ;;
      esac
    }
    func_verbose "package_version='$package_version'"

    require_package_version=:
}


# require_source_base
# -------------------
# Ensure that source_base has a sensible value, extracted from
# `gnulib-cache.m4' if possible.
require_source_base=func_require_source_base
func_require_source_base ()
  {
    $debug_cmd

    $require_gnulib_cache

    test -f "$gnulib_cache" && test x = "x$source_base" && {
      $require_macro_dir

      func_extract_trace "gl_SOURCE_BASE" "$gnulib_cache"

      source_base="$func_extract_trace_result"

      func_verbose "source_base='$source_base'"
    }

    require_source_base=:
}


# require_vc_ignore_files
# -----------------------
# Ensure that `$vc_ignore' has been processed to list VCS ignore files
# in `$vc_ignore_files'
require_vc_ignore_files=func_require_vc_ignore_files
func_require_vc_ignore_files ()
{
    $debug_cmd

    test -n "$vc_ignore" || vc_ignore=auto

    if test auto = "$vc_ignore" && test x = x"$vc_ignore_files"; then
      vc_ignore_files=
      test -d .git && vc_ignore_files=.gitignore
      test -d CVS && vc_ignore_files="$vc_ignore_files .cvsignore"
    else
      vc_ignore_files="$vc_ignore"
    fi

    func_verbose "vc_ignore_files='$vc_ignore_files'"

    require_vc_ignore_files=:
}


## ------------------##
## Helper functions. ##
## ------------------##

# This section contains the helper functions used by the rest of `bootstrap'.

# func_len STRING
# ---------------
# STRING may not start with a hyphen.
if (eval 'x=123; test x${#x} = "x3"') 2>/dev/null
then
  # This is an XSI compatible shell, allowing a faster implementation...
  eval 'func_len ()
  {
    $debug_cmd

    func_len_result=${#1}
  }'
else
  # ...otherwise fall back to using expr, which is often a shell builtin.
  func_len ()
  {
    $debug_cmd

    func_len_result=`expr "$1" : ".*" 2>/dev/null || echo 0`
  }
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=; unset $1; }
}
unset=func_unset


# func_cmp_s FILE1 FILE2
# ----------------------
# Return non-zero exit status unless FILE1 and FILE2 are identical, without
# any output at all, even error messages.
func_cmp_s ()
{
    $debug_cmd

    # This function relies on non-zero exit status, which will cause the
    # program to exit when running in `set -e' mode.
    $CMP "$@" >/dev/null 2>&1
}


# func_grep_q EXPRESSION [FILENAME..].
# ------------------------------------
# Check whether EXPRESSION matches any line of any listed FILENAME,
# without any output at all, even error messages.
func_grep_q ()
{
    $debug_cmd

    # This function relies on non-zero exit status, which will cause the
    # program to exit when running in `set -e' mode.
    $GREP "$@" >/dev/null 2>&1
}


# func_ifcontains LIST MEMBER YES-CMD [NO-CMD]
# --------------------------------------------
# If whitespace-separated LIST contains MEMBER then execute YES-CMD,
# otherwise if NO-CMD was give, execute that.
func_ifcontains ()
{
    $debug_cmd

    # The embedded echo is to squase whitespace before globbing.
    my_wslist=`echo " "$1" "`
    my_member=$2
    my_yes_cmd=$3
    my_no_cmd=${4-":"}

    case $my_wslist in
      *" $my_member "*)
        eval "$my_yes_cmd"
	my_status=$?
	;;
      *)
	eval "$my_no_cmd"
	my_status=$?
	;;
    esac

    test "$my_status" -eq 0 || exit $my_status
}


# func_append_u 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_u 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_u ()
{
    $debug_cmd

    eval my_current_value='`echo $'$1'`'
    my_delim=`expr "$2" : '\(.\)'`

    case $my_delim$my_current_value$my_delim in
      *"$2$my_delim"*) ;;
      *) func_append "$@" ;;
    esac
}


# func_strpad STR WIDTH CHAR
# --------------------------
# Trim STR, or pad with CHAR to force a total length of WIDTH.
func_strpad ()
{
    $debug_cmd

    my_width=`expr "$2" - 1`
    func_strpad_result=`echo "$1" |$SED '
        :a
        s|^.\{0,'"$my_width"'\}$|&'"$3"'|
        ta
    '`
}


# func_strrpad STR WIDTH CHAR
# ---------------------------
# Trim STR, or right-justify-pad with CHAR to force a total length of
# WIDTH.
func_strrpad ()
{
    $debug_cmd

    my_width=`expr "$2" - 1`
    func_strrpad_result=`echo "$1" |$SED '
        :a
        s|^.\{0,'"$my_width"'\}$|'"$3"'&|
        ta
    '`
}


# func_strrow INDENT FIELD WIDTH [FIELDn WIDTHn]...
# -------------------------------------------------
# Return a string containing each FIELD left justified to WIDTH, with
# the whole thing indented by INDENT spaces.  This function is used to
# render one row of aligned columns for a table by func_strtable().
func_strrow ()
{
    $debug_cmd

    func_strrow_linelen="$1"; shift

    my_row=
    while test $# -gt 0; do
      func_strrow_linelen=`expr $func_strrow_linelen + $2`
      func_strpad "$1" $2 " "
      func_append my_row "$func_strpad_result"
      shift; shift
    done

    func_strrpad "$my_row" $func_strrow_linelen " "
    func_strrow_result="$func_strrpad_result"
}


# func_strtable INDENT WIDTH1...WIDTHn HEADER1...HEADERn FIELD1...FIELDn
# ----------------------------------------------------------------------
# Generate a string of newline-separated rows arranged in lined-up
# columns of the given WIDTHs, with the entire table indented by INDENT
# spaces.  The number of columns is determined by the number of integer
# valued WIDTH arguments following INDENT.  The next set (i.e. a number
# of arguments equal to the number of WIDTH arguments) of fields are
# treated as the table's column HEADERs, and are separated from the
# remainder of the table by an indented row of `-' characters. Remaining
# arguments are each aligned below the next available header, wrapping
# to a new row as necessary.  Finally another row of `-' characters is
# added to mark the end of the table.
#
# For example an unindented 3 column table with 2 rows of data would be
# generated by this call:
#
#    func_strtable 3 20 10 25 \
#        Header1 Header2 Header3 \
#        Row1Col1 Row1Col2 Row1Col3 \
#        Row2Col1 Row2Col2 Row2Col3
#
# returning the following string:
#
# "   Header1             Header2   Header3
#     -------------------------------------------------------
#     Row1Col1            Row1Col2  Row1Col3
#     Row2Col1            Row2Col2  Row2Col3
#     -------------------------------------------------------"
func_strtable ()
{
    $debug_cmd

    # Save the indent value, we'll need it for each row we render.
    my_indent="$1"; shift

    # Collect remaining numeric args into a list for reuse between
    # members of each row when we call func_strrow later.
    my_widths="$1"; shift
    while test 0 -lt `expr "$1" : '[1-9][0-9]*$'`; do
      func_append my_widths " $1"; shift
    done

    # Extract the same number of positional parameters as there are
    # width elements - we'll do the header rows separately so that
    # we can insert a divider line.
    my_header="$my_indent"
    for my_width in $my_widths; do
      func_append my_header " $1 $my_width"; shift
    done
    func_strrow $my_header

    # Strip off the indent, and make a divider with `-' chars, then
    # reindent.
    my_divider=`echo "$func_strrow_result" \
        |$SED 's|[^ ]|-|g
            :a
            s|- |--|g
            ta
        '`

    # Append the header and divider to the running result.
    func_append func_strtable_result "\
$func_strrow_result
$my_divider
"

    # The remaining rows are zipped between the width values we
    # unwound earlier just like the header row above.
    while test $# -gt 0; do
      my_row="$my_indent"
      for my_width in $my_widths; do
        func_append my_row " $1 $my_width"; shift
      done
      func_strrow $my_row
      func_append func_strtable_result "\
$func_strrow_result
"
    done

    # Mark the end of the table with a final divider line.
    func_append func_strtable_result "$my_divider"
}


# func_echo ARG...
# ----------------
# Echo program name prefixed message, taking newlines into account.
func_echo ()
{
    my_message="$*"

    save_IFS="$IFS"
    IFS="$nl"
    for my_line in $my_message; do
      IFS="$save_IFS"
      echo "$progname: $my_line"
    done
    IFS="$save_IFS"
}


# func_verbose ARG...
# -------------------
# Echo program name prefixed message in verbose mode only.
func_verbose ()
{
    $opt_verbose && func_echo ${1+"$@"}
}


# func_error ARG...
# -----------------
# Echo program name prefixed message to standard error.
func_error ()
{
    my_message="$*"

    save_IFS="$IFS"
    IFS="$nl"
    for my_line in $my_message; do
      IFS="$save_IFS"
      echo "$progname: $bold_on$my_line$bold_off" 1>&2
    done
    IFS="$save_IFS"
}

# Allow display of bold text on terminals that support it
bold_on=
bold_off=
if test -t 1; then
  if test -n "`tput bold 2>/dev/null`" \
      && test -n "`tput sgr0 2>/dev/null`"
  then
    bold_on=`tput bold`
    bold_off=`tput sgr0`
  fi
fi


# func_fatal_error ARG...
# -----------------------
# Echo program name prefixed message to standard error, and exit.
func_fatal_error ()
{
    func_error ${1+"$@"}
    exit $EXIT_FAILURE
}


# func_internal_error ARG...
# --------------------------
# Echo program name prefixed message to standard error, and exit.
func_internal_error ()
{
    func_fatal_error "INTERNAL ERROR: " ${1+"$@"} "
                Please report this bug to \`bug-gnulib@gnu.org'
                in as much detail as possible."
}


# func_permissions_error FILE-OR-DIRECTORY
# ----------------------------------------
# Echo program name prefixed permissions error message to standard
# error, and exit.
func_permissions_error ()
{
    $debug_cmd

    func_fatal_error "error: Failed to create \`$1', check permissions."
}


# func_warning CATEGORY ARG...
# ----------------------------
# Echo program name prefixed warning message to standard error. Warning
# messages can be filtered according to CATEGORY.
func_warning ()
{
    $debug_cmd

    case " $warning_categories " in
      *" $1 "*) ;;
      *) func_internal_error "invalid warning category \`$1'" ;;
    esac

    my_category="$1"
    shift

    case " $opt_warning " in
      *" $my_category "*) $warning_func ${1+"$@"} ;;
    esac
}


# func_fatal_help ARG...
# ----------------------
# Echo program name prefixed message to standard error, followed by
# a help hint, and exit.
func_fatal_help ()
{
    $debug_cmd

    func_error ${1+"$@"}
    func_fatal_error "$fatal_help"
}
fatal_help="Try \`$progname --help' for more information."  ## default


# func_version
# ------------
# Echo version message to standard output and exit.
func_version ()
{
    $debug_cmd

    printf '%s\n' "$progname $scriptversion"
    $SED -n '/(C)/!b go
        :more
        /\./!{
          N
          s|\n# | |
          b more
        }
        :go
        /^# Written by /,/# warranty; / {
          s|^# ||
          s|^# *$||
          s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
          p
        }
        /^# Written by / {
          s|^# ||
          p
        }' < "$progpath"

    exit $?
}


# func_usage_message
# ------------------
# Echo short help message to standard output.
func_usage_message ()
{
    $debug_cmd

    echo "$progpath [OPTION]..."
    echo ""
    echo "$usage_message"
}


# func_usage
# ----------
# Echo short help message to standard output and exit.
func_usage ()
{
    $debug_cmd

    func_usage_message
    echo "Run \`$progname --help |more' for full usage"
    exit 0
}


# func_help
# ---------
# Echo long help message to standard output and exit.
func_help ()
{
    $debug_cmd

    func_usage_message
    echo "$long_help_message"
    exit 0
}


# func_missing_arg ARGNAME
# ------------------------
# Echo program name prefixed message to standard error and set global
# exit_cmd.
func_missing_arg ()
{
    $debug_cmd

    func_error "error: Missing argument for \`$1'."
    exit_cmd=exit
}


# func_split_short_opt SHORTOPT
# -----------------------------
# Set func_split_short_opt_name and func_split_short_opt_arg shell
# variables after splitting SHORTOPT after the 2nd character.
if (eval 'x=-abc; y=${x#??}; z=${x%$y}; test x$y$z = xbc-a') 2>/dev/null
then
  # This is an XSI compatible shell, allowing a faster implementation...
  eval 'func_split_short_opt ()
  {
      $debug_cmd

      func_split_short_opt_arg=${1#??}
      func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
  }'
else
  # ...otherwise fall back to using expr, which is often a shell builtin.
  func_split_short_opt ()
  {
      $debug_cmd

      func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'`
      func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
  }
fi #func_split_short_opt


# func_split_equals STRING
# ------------------------
# Set func_split_equals_lhs and func_split_equals_rhs shell variables after
# splitting STRING at the `=' sign.
if (eval 'x='--ab=cd'; y=${x#*=}; z=${x%%=*}; test x$y$z = xcd--ab') 2>/dev/null
then
  # This is an XSI compatible shell, allowing a faster implementation...
  eval 'func_split_equals ()
  {
      $debug_cmd

      func_split_equals_lhs=${1%%=*}
      func_split_equals_rhs=${1#*=}
      test "x$func_split_equals_lhs" = "x$1" \
        && func_split_equals_rhs=""
  }'
else
  # ...otherwise fall back to using expr, which is often a shell builtin.
  func_split_equals ()
  {
      $debug_cmd

      func_split_equals_lhs=`expr "x$1" : 'x\([^=]*)'`
      func_split_equals_rhs=""
      test "x$func_split_equals_lhs" = "x$1" \
        || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
  }
fi #func_split_equals


# func_quote_for_eval ARG...
# --------------------------
# Aesthetically quote ARGs to be evaled later.
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
# is double-quoted, suitable for a subsequent eval, whereas
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
# which are still active within double quotes backslashified.
sed_quote_subst='s|\([`"$\\]\)|\\\1|g'
func_quote_for_eval ()
{
    $debug_cmd

    func_quote_for_eval_result=

    while test $# -gt 0; do
      case $1 in
        *[\\\`\"\$]*)
          my_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;;
        *)
          my_unquoted_arg="$1" ;;
      esac

      case $my_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.
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
          my_quoted_arg="\"$my_unquoted_arg\""
          ;;
        *)
          my_quoted_arg="$my_unquoted_arg" ;;
      esac
      test -n "$func_quote_for_eval_result" \
          && func_append func_quote_for_eval_result " "
      func_append func_quote_for_eval_result "$my_quoted_arg"
      shift
    done
}


# func_show_eval CMD [FAIL_EXP]
# -----------------------------
# Unless opt_silent 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

    my_cmd="$1"
    my_fail_exp="${2-:}"

    ${opt_silent-false} || {
      func_quote_for_eval $my_cmd
      eval func_truncate_cmd $func_quote_for_eval_result
      func_echo "running: $func_truncate_cmd_result"
    }

    ${opt_dry_run-false} || {
      eval "$my_cmd"
      my_status=$?
      test "$my_status" -eq 0 || eval "(exit $my_status); $my_fail_exp"
    }
}


# func_truncate_cmd CMD [ARG]...
# ------------------------------
# For unreasonably long commands (such as a gnulib-tool invocation with
# the full module list for import), truncate CMD after the second non-
# option ARG.
func_truncate_cmd ()
{
    $debug_cmd

    my_last_arg_opt_p=false
    func_truncate_cmd_result=

    set dummy "$@"; shift

    while test $# -gt 0; do
      my_opt="$1"; shift

      test -n "$func_truncate_cmd_result" \
          && func_append func_truncate_cmd_result ' '
      func_append func_truncate_cmd_result "$my_opt"

      func_len "x$func_truncate_cmd_result"

      case $my_opt in
        -*) my_last_arg_opt_p=: ;;
        *)  $my_last_arg_opt_p \
                || test $min_cmd_len -gt $func_len_result \
                || break
            my_last_arg_opt_p=false
            ;;
      esac
    done

    test $# -gt 0 && func_append func_truncate_cmd_result "..."
}


# func_extract_trace MACRO_NAME [FILENAME]...
# -------------------------------------------
# set `$func_extract_trace_result' to a colon delimited list of
# arguments to MACRO_NAME in FILENAME. If no FILENAME is not given,
# then `configure.ac' is assumed.
func_extract_trace ()
{
    $debug_cmd

    $require_configure_ac
    $require_gnu_m4

    my_macro="$1"; shift
    test $# -gt 0 || {
      set dummy $configure_ac
      shift
    }

    # Generate an error if the first file is missing
    <"$1"

    # Sadly, we can't use `autom4te' tracing to extract macro
    # arguments, because it complains about things we want to
    # ignore at bootstrap time - like missing m4_include files;
    # AC_PREREQ being newer than the installed autoconf; and
    # returns nothing when tracing `AM_INIT_AUTOMAKE' when
    # aclocal hasn't been generated yet.
    #
    # The following tries to emulate a less persnickety version
    # of (and due to not having to wait for Perl startup on
    # every invocation, it's probably faster too):
    #
    #    autom4te --language=Autoconf --trace=$my_macro:\$% "$@"
    #
    # First we give a minimal set of macro declarations to M4
    # to prime it for reading Autoconf macros, while still
    # providing some of the functionality generally used at
    # m4-time to supply dynamic arguments to Autocof functions,
    # but without following `m4_s?include' files.
    #
    # We discard M4's stdout, but the M4 trace output from reading
    # our "autoconf.mini" followed by any other files passed to
    # this function is then scanned by sed to transform it into
    # a colon delimited argument list assigned to a shell variable.
    #
    # Finally, we `eval' the sed generated assignment to get
    # the result back into this script for further use by callers
    # of this function.

    func_extract_trace_result=
    eval `echo '
        # Initialisation.
        m4_changequote([,])
        m4_define([m4_copy],   [m4_define([$2], m4_defn([$1]))])
        m4_define([m4_rename], [m4_copy([$1], [$2])m4_undefine([$1])])

        # Disable these macros.
        m4_undefine([m4_dnl])
        m4_undefine([m4_include])
        m4_undefine([m4_m4exit])
        m4_undefine([m4_m4wrap])
        m4_undefine([m4_maketemp])

        # Copy and rename macros not handled by "m4 --prefix".
        m4_define([dnl],         [m4_builtin([dnl])])
        m4_copy([m4_define],     [m4_defun])
        m4_rename([m4_ifelse],   [m4_if])
        m4_ifdef([m4_mkstemp],   [m4_undefine([m4_mkstemp])])
        m4_rename([m4_patsubst], [m4_bpatsubst])
        m4_rename([m4_regexp],   [m4_bregexp])

        # "m4sugar.mini" - useful m4-time macros for dynamic arguments.
        # If we discover packages that need more m4 macros defined in
        # order to bootstrap correctly, add them here:
        m4_define([m4_bmatch],
            [m4_if([$#], 0, [], [$#], 1, [], [$#], 2, [$2],
                   [m4_if(m4_bregexp([$1], [$2]), -1,
                          [$0([$1], m4_shift3($@))], [$3])])])
        m4_define([m4_ifndef], [m4_ifdef([$1], [$3], [$2])])
        m4_define([m4_ifset],
            [m4_ifdef([$1], [m4_ifval(m4_defn([$1]), [$2], [$3])], [$3])])
        m4_define([m4_require], [$1])
        m4_define([m4_shift3], [m4_shift(m4shift(m4shift($@)))])

        # "autoconf.mini" - things from autoconf macros we care about.
        m4_copy([m4_defun], [AC_DEFUN])

        # Dummy definition for the macro we want to trace.
        # AM_INIT_AUTOMAKE at least produces no trace without this.
        AC_DEFUN(['"$my_macro"'])' \
    |$M4 -daq --prefix --trace="$my_macro" - "$@" 2>&1 1>/dev/null \
    |$SED -n 's|#.*$||
        /^m4trace: -1- '"$my_macro"'/ {
          s|^m4trace: -1- '"$my_macro"'[([]*|func_extract_trace_result='\''|
          s|], [[]|:|g
          s|[])]*$|:'\''|
          s|[^'\'']$|\&'\''|
          p
        }'`

    # Leave the ':' sentinel in place for successfully traced macros
    # without arguments, otherwise remove it so that the results of
    # single-argument macros can be used without additional parsing.
    test : = "$func_extract_trace_result" \
        || func_extract_trace_result=`echo "$func_extract_trace_result" |$SED 's|:$||'`
}


# func_insert_sorted_if_absent STR FILE...
# ----------------------------------------
# If $STR is not already on a line by itself in $FILE, insert it,
# sorting the new contents of the file and replacing $FILE with the result.
func_insert_sorted_if_absent ()
{
    $debug_cmd

    str=$1
    shift

    for file
    do
      test -f $file || touch $file

      func_grep_q "$str" "$file" \
          && func_verbose "inserting \`$str' into \`$file'"

      echo "$str" |sort -u - $file |func_cmp_s - $file \
        || echo "$str" |sort -u - $file -o $file \
        || func_permissions_error "$file"
    done
}


# func_sort_ver VER1 VER2
# -----------------------
# 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 ()  # sort -V is not generally available
{
    $debug_cmd

    ver1="$1"
    ver2="$2"

    # Split on '.' and compare each component.
    i=1
    while : ; do
      p1=`echo "$ver1" |cut -d. -f$i`
      p2=`echo "$ver2" |cut -d. -f$i`
      if test ! "$p1"; then
        echo "$1 $2"
        break
      elif test ! "$p2"; then
        echo "$2 $1"
        break
      elif test ! "$p1" = "$p2"; then
        if test "$p1" -gt "$p2" 2>/dev/null; then # numeric comparison
          echo "$2 $1"
        elif test "$p2" -gt "$p1" 2>/dev/null; then # numeric comparison
          echo "$1 $2"
        else # numeric, then lexicographic comparison
          lp=`printf "$p1\n$p2\n" |sort -n |tail -n1`
          if test "$lp" = "$p2"; then
            echo "$1 $2"
          else
            echo "$2 $1"
          fi
        fi
        break
      fi
      i=`expr $i + 1`
    done
}


# func_get_version APP
# --------------------
# echo the version number (if any) of APP, which is looked up along your
# PATH.
func_get_version ()
{
    $debug_cmd

    app=$1

    { $app --version || $app --version </dev/null; } >/dev/null 2>&1 \
      || return 1

    $app --version 2>&1 \
    |$SED -n '# extract version within line
          s|.*[v ]\{1,\}\([0-9]\{1,\}\.[.a-z0-9-]*\).*|\1|
          t done

          # extract version at start of line
          s|^\([0-9]\{1,\}\.[.a-z0-9-]*\).*|\1|
          t done

          d

          :done
          #the following essentially does s|5.005|5.5|
          s|\.0*\([1-9]\)|.\1|g
          p
          q'
}


# func_check_versions APP1 VER1 URL1 ...[APPN VERN URLN]
# ------------------------------------------------------
func_check_versions ()
{
    $debug_cmd

    func_check_versions_result=:

    while test $# -gt 0; do
      my_app="$1"; shift
      my_reqver="$1"; shift
      my_url="$1"; shift

      # Honor $APP variables ($TAR, $AUTOCONF, etc.)
      my_appvar=`echo $my_app |tr '[a-z]' '[A-Z]'`
      test "$my_appvar" = TAR && my_appvar=AMTAR
      eval "my_app=\${$my_appvar-$my_app}"
      my_instver=`func_get_version $my_app`

      test -z "$my_instver" \
          || func_verbose "found \`$my_app' version $my_instver"

      # Fail if --version didn't work.
      if test -z "$my_instver"; then
        func_error "error: \`$my_app' not found"
        func_check_versions_result=false

      # Fail if a new version than what we have is required.
      elif test "$my_reqver" != "-"; then
        my_newer=`func_sort_ver $my_reqver $my_instver |cut -d' ' -f2`
        test "$my_newer" != "$my_instver" && {
          func_error "\
error: \`$my_app' version == $my_instver is too old
       \`$my_app' version >= $my_reqver is required"
          func_check_versions_result=false
        }
      fi
    done
}


# func_cleanup_gnulib
# -------------------
# Recursively delete everything below the path in the global variable
# GNULIB_PATH.
func_cleanup_gnulib ()
{
    $debug_cmd

    my_status=$?
    $RM -fr "$gnulib_path"
    exit $my_status
}


# func_download_po_files SUBDIR DOMAIN
# ------------------------------------
func_download_po_files ()
{
    $debug_cmd

    func_echo "getting translations into $1 for $2..."
    cmd=`printf "$po_download_command_format" "$2" "$1"`
    eval "$cmd"
}


# func_find_tool ENVVAR NAMES...
# ------------------------------
# Search for a required program.  Use the value of ENVVAR, if set,
# otherwise find the first of the NAMES that can be run (i.e.,
# supports --version).  If found, set ENVVAR to the program name,
# die otherwise.
func_find_tool ()
{
    $debug_cmd

    find_tool_envvar=$1
    shift
    find_tool_names=$@
    eval "find_tool_res=\$$find_tool_envvar"
    if test x"$find_tool_res" = x; then
      for i
      do
        if ($i --version </dev/null) >/dev/null 2>&1; then
          find_tool_res=$i
          break
        fi
      done
    else
      find_tool_error_prefix="\$$find_tool_envvar: "
    fi
    test x"$find_tool_res" = x && func_fatal_error "\
error: One of these is required:
       $find_tool_names"

    ($find_tool_res --version </dev/null) >/dev/null 2>&1 \
      || func_fatal_error "\
error: ${find_tool_error_prefix}Cannot run \`$find_tool_res --version'"

    eval "$find_tool_envvar=\$find_tool_res"
    eval "export $find_tool_envvar"
}


# func_update_po_files PO_DIR DOMAIN
# ----------------------------------
# Mirror .po files to $po_dir/.reference and copy only the new
# or modified ones into $po_dir.  Also update $po_dir/LINGUAS.
# Note po files that exist locally only are left in $po_dir but will
# not be included in LINGUAS and hence will not be distributed.
func_update_po_files ()
{
    $debug_cmd

    # Directory containing primary .po files.
    # Overwrite them only when we're sure a .po file is new.
    po_dir=$1
    domain=$2

    # Mirror *.po files into this dir.
    # Usually contains *.s1 checksum files.
    ref_po_dir="$po_dir/.reference"

    test -d $ref_po_dir || mkdir $ref_po_dir || return
    func_download_po_files $ref_po_dir $domain \
      && ls "$ref_po_dir"/*.po 2>/dev/null \
         |$SED 's|.*/||; s|\.po$||' > "$po_dir/LINGUAS" || return

    # Find sha1sum, named gsha1sum on MacPorts, and shasum on MacOS 10.6.
    func_find_tool SHA1SUM sha1sum gsha1sum shasum

    langs=`cd $ref_po_dir && echo *.po|$SED 's|\.po||g'`
    test "$langs" = '*' && langs=x
    for po in $langs; do
      case $po in x) continue;; esac
      new_po="$ref_po_dir/$po.po"
      cksum_file="$ref_po_dir/$po.s1"
      if ! test -f "$cksum_file" ||
          ! test -f "$po_dir/$po.po" ||
          ! $SHA1SUM -c --status "$cksum_file" \
              < "$new_po" > /dev/null; then
        echo "updated $po_dir/$po.po..."
        cp "$new_po" "$po_dir/$po.po" \
          && $SHA1SUM < "$new_po" > "$cksum_file"
      fi
    done
}



## ----------------- ##
## Global variables. ##
## ----------------- ##

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.

exit_status=$EXIT_SUCCESS

# Allow overriding, eg to get a function call trace:
#    debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash bootstrap
debug_cmd="${debug_cmd-:}"
exit_cmd=:

dirname='s|/[^/]*$||'
basename='s|^.*/||'

nl='
'

# 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 "$basename"`

## -------------------------------------------------- ##
## Source package customisations in `bootstrap.conf'. ##
## -------------------------------------------------- ##

# Override the default configuration, if necessary.
# Make sure that bootstrap.conf is sourced from the current directory
# if we were invoked as "sh bootstrap".
case $0 in
  */*) test -r "$0.conf" && . "$0.conf" ;;
  *) test -r "$0.conf" && . ./"$0.conf" ;;
esac


## ------------------------------- ##
## Actually perform the bootstrap. ##
## ------------------------------- ##

func_bootstrap ${1+"$@"}

# The End.
exit $exit_status

# Local variables:
# mode: shell-script
# sh-indentation: 2
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC"
# time-stamp-end: "; # UTC"
# End: