Fix last ChangeLog entry.

[gnulib.git] / gnulib-tool

#! /bin/sh
#
# Copyright (C) 2002-2021 Free Software Foundation, Inc.
#
# 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 <https://www.gnu.org/licenses/>.
#

# This program is meant for authors or maintainers which want to import
# modules from gnulib into their packages.

# CODING STYLE for this file:
# * Indentation: Indent by 2 spaces. Indent case clauses by 2 spaces as well.
# * Shell variable references: Use double-quote around shell variable
#   references always (except when word splitting is explicitly desired),
#   even when you know the double-quote are not needed.  This style tends to
#   avoid undesired word splitting caused by omitted double-quotes (the
#   number one mistake in shell scripts).
#   When the referenced variable can only have a finite number of possible
#   values and these values are all simple words (e.g. true and false), it's
#   OK to omit the double-quotes.
# * Backquotes:
#   - Use backquotes like in `command`, not $(command).
#   - Don't use `command` inside double-quotes. Instead assign the result of
#     `command` to a variable, and use the value of the variable afterwards.
# * Functions:
#   - All functions that don't emulate a program or shell built-in have a name
#     that starts with 'func_'.
#   - Document the implicit and explicit arguments of all functions, as well
#     as their output variables and side effects.
# * Use  test condition  instead of  [ condition ].
# * Minimize the use of eval; when you need it, make sure the string to be
#   evaluated has a very simple syntactic structure.

progname=$0
package=gnulib
nl='
'
IFS=" ""        $nl"

# You can set AUTOCONFPATH to empty if autoconf 2.64 is already in your PATH.
AUTOCONFPATH=
#case $USER in
#  bruno )
#    AUTOCONFBINDIR=/arch/x86-linux/gnu-inst-autoconf/2.64/bin
#    AUTOCONFPATH="eval env PATH=${AUTOCONFBINDIR}:\$PATH "
#    ;;
#esac

# You can set AUTOMAKEPATH to empty if automake 1.11 is already in your PATH.
AUTOMAKEPATH=

# You can set GETTEXTPATH to empty if autopoint 0.15 is already in your PATH.
GETTEXTPATH=

# You can set LIBTOOLPATH to empty if libtoolize 2.x is already in your PATH.
LIBTOOLPATH=

# If you didn't set AUTOCONFPATH and AUTOMAKEPATH, you can also set the
# variables AUTOCONF, AUTOHEADER, ACLOCAL, AUTOMAKE, AUTORECONF individually.
if test -z "${AUTOCONF}" || test -n "${AUTOCONFPATH}"; then
  AUTOCONF="${AUTOCONFPATH}autoconf"
fi
if test -z "${AUTOHEADER}" || test -n "${AUTOCONFPATH}"; then
  AUTOHEADER="${AUTOCONFPATH}autoheader"
fi
if test -z "${ACLOCAL}" || test -n "${AUTOMAKEPATH}"; then
  ACLOCAL="${AUTOMAKEPATH}aclocal"
fi
if test -z "${AUTOMAKE}" || test -n "${AUTOMAKEPATH}"; then
  AUTOMAKE="${AUTOMAKEPATH}automake"
fi
if test -z "${AUTORECONF}" || test -n "${AUTOCONFPATH}"; then
  AUTORECONF="${AUTOCONFPATH}autoreconf"
fi

# If you didn't set GETTEXTPATH, you can also set the variable AUTOPOINT.
if test -z "${AUTOPOINT}" || test -n "${GETTEXTPATH}"; then
  AUTOPOINT="${GETTEXTPATH}autopoint"
fi

# If you didn't set LIBTOOLPATH, you can also set the variable LIBTOOLIZE.
if test -z "${LIBTOOLIZE}" || test -n "${LIBTOOLPATH}"; then
  LIBTOOLIZE="${LIBTOOLPATH}libtoolize"
fi

# You can set MAKE.
if test -z "${MAKE}"; then
  MAKE=make
fi

# When using GNU sed, turn off as many GNU extensions as possible,
# to minimize the risk of accidentally using non-portable features.
# However, do this only for gnulib-tool itself, not for the code that
# gnulib-tool generates, since we don't want "sed --posix" to leak
# into makefiles. And do it only for sed versions 4.2 or newer,
# because "sed --posix" is buggy in GNU sed 4.1.5, see
# <https://lists.gnu.org/r/bug-gnulib/2009-02/msg00225.html>.
if (alias) > /dev/null 2>&1 \
   && echo | sed --posix -e d >/dev/null 2>&1 \
   && case `sed --version | sed -e 's/^[^0-9]*//' -e 1q` in \
        [1-3]* | 4.[01]*) false;; \
        *) true;; \
      esac \
   ; then
  # Define sed as an alias.
  # It is not always possible to use aliases. Aliases are guaranteed to work
  # if the executing shell is bash and either it is invoked as /bin/sh or
  # is a version >= 2.0, supporting shopt. This is the common case.
  # Two other approaches (use of a variable $sed or of a function func_sed
  # instead of an alias) require massive, fragile code changes.
  # An other approach (use of function sed) requires `which sed` - but
  # 'which' is hard to emulate, due to missing "test -x" on some platforms.
  if test -n "$BASH_VERSION"; then
    shopt -s expand_aliases >/dev/null 2>&1
  fi
  alias sed='sed --posix'
fi

# sed_noop is a sed expression that does nothing.
# An empty expression does not work with the native 'sed' on AIX 6.1.
sed_noop='s,x,x,'

# sed_comments is true or false, depending whether 'sed' supports comments.
# AIX 5.3 sed barfs over indented comments.
if echo fo | sed -e 's/f/g/
# s/o/u/
 # indented comment
s/o/e/' 2>/dev/null | grep ge > /dev/null; then
  sed_comments=true
else
  sed_comments=false
fi

# func_usage
# outputs to stdout the --help usage message.
func_usage ()
{
  echo "\
Usage: gnulib-tool --list
       gnulib-tool --find filename
       gnulib-tool --import [module1 ... moduleN]
       gnulib-tool --add-import [module1 ... moduleN]
       gnulib-tool --remove-import [module1 ... moduleN]
       gnulib-tool --update
       gnulib-tool --create-testdir --dir=directory [module1 ... moduleN]
       gnulib-tool --create-megatestdir --dir=directory [module1 ... moduleN]
       gnulib-tool --test --dir=directory module1 ... moduleN
       gnulib-tool --megatest --dir=directory [module1 ... moduleN]
       gnulib-tool --extract-description module
       gnulib-tool --extract-comment module
       gnulib-tool --extract-status module
       gnulib-tool --extract-notice module
       gnulib-tool --extract-applicability module
       gnulib-tool --extract-filelist module
       gnulib-tool --extract-dependencies module
       gnulib-tool --extract-recursive-dependencies module
       gnulib-tool --extract-autoconf-snippet module
       gnulib-tool --extract-automake-snippet module
       gnulib-tool --extract-include-directive module
       gnulib-tool --extract-link-directive module
       gnulib-tool --extract-recursive-link-directive module
       gnulib-tool --extract-license module
       gnulib-tool --extract-maintainer module
       gnulib-tool --extract-tests-module module
       gnulib-tool --copy-file file [destination]

Operation modes:

      --list                print the available module names
      --find                find the modules which contain the specified file
      --import              import the given modules into the current package
      --add-import          augment the list of imports from gnulib into the
                            current package, by adding the given modules;
                            if no modules are specified, update the current
                            package from the current gnulib
      --remove-import       reduce the list of imports from gnulib into the
                            current package, by removing the given modules
      --update              update the current package, restore files omitted
                            from version control
      --create-testdir      create a scratch package with the given modules
      --create-megatestdir  create a mega scratch package with the given modules
                            one by one and all together
      --test                test the combination of the given modules
                            (recommended to use CC=\"gcc -Wall\" here)
      --megatest            test the given modules one by one and all together
                            (recommended to use CC=\"gcc -Wall\" here)
      --extract-description        extract the description
      --extract-comment            extract the comment
      --extract-status             extract the status (obsolete etc.)
      --extract-notice             extract the notice or banner
      --extract-applicability      extract the applicability
      --extract-filelist           extract the list of files
      --extract-dependencies       extract the dependencies
      --extract-recursive-dependencies  extract the dependencies of the module
                                        and its dependencies, recursively, all
                                        together, but without the conditions
      --extract-autoconf-snippet   extract the snippet for configure.ac
      --extract-automake-snippet   extract the snippet for library makefile
      --extract-include-directive  extract the #include directive
      --extract-link-directive     extract the linker directive
      --extract-recursive-link-directive  extract the linker directive of the
                                          module and its dependencies,
                                          recursively, all together
      --extract-license            report the license terms of the source files
                                   under lib/
      --extract-maintainer         report the maintainer(s) inside gnulib
      --extract-tests-module       report the unit test module, if it exists
      --copy-file                  copy a file that is not part of any module
      --help                Show this help text.
      --version             Show version and authorship information.

General options:

      --dir=DIRECTORY       Specify the target directory.
                            For --import, this specifies where your
                            configure.ac can be found.  Defaults to current
                            directory.
      --local-dir=DIRECTORY  Specify a local override directory where to look
                            up files before looking in gnulib's directory.
      --cache-modules       Enable module caching optimization.
      --no-cache-modules    Disable module caching optimization.
      --verbose             Increase verbosity. May be repeated.
      --quiet               Decrease verbosity. May be repeated.

Options for --import, --add/remove-import, --update:

      --dry-run             Only print what would have been done.

Options for --import, --add/remove-import:

      --with-tests          Include unit tests for the included modules.

Options for --create-[mega]testdir, --[mega]test:

      --without-tests       Don't include unit tests for the included modules.

Options for --import, --add/remove-import,
            --create-[mega]testdir, --[mega]test:

      --with-obsolete       Include obsolete modules when they occur among the
                            dependencies. By default, dependencies to obsolete
                            modules are ignored.
      --with-c++-tests      Include even unit tests for C++ interoperability.
      --without-c++-tests   Exclude unit tests for C++ interoperability.
      --with-longrunning-tests
                            Include even unit tests that are long-runners.
      --without-longrunning-tests
                            Exclude unit tests that are long-runners.
      --with-privileged-tests
                            Include even unit tests that require root
                            privileges.
      --without-privileged-tests
                            Exclude unit tests that require root privileges.
      --with-unportable-tests
                            Include even unit tests that fail on some platforms.
      --without-unportable-tests
                            Exclude unit tests that fail on some platforms.
      --with-all-tests      Include all kinds of problematic unit tests.
      --avoid=MODULE        Avoid including the given MODULE. Useful if you
                            have code that provides equivalent functionality.
                            This option can be repeated.
      --conditional-dependencies
                            Support conditional dependencies (may save configure
                            time and object code).
      --no-conditional-dependencies
                            Don't use conditional dependencies.
      --libtool             Use libtool rules.
      --no-libtool          Don't use libtool rules.

Options for --import, --add/remove-import:

      --lib=LIBRARY         Specify the library name.  Defaults to 'libgnu'.
      --source-base=DIRECTORY
                            Directory relative to --dir where source code is
                            placed (default \"lib\").
      --m4-base=DIRECTORY   Directory relative to --dir where *.m4 macros are
                            placed (default \"m4\").
      --po-base=DIRECTORY   Directory relative to --dir where *.po files are
                            placed (default \"po\").
      --doc-base=DIRECTORY  Directory relative to --dir where doc files are
                            placed (default \"doc\").
      --tests-base=DIRECTORY
                            Directory relative to --dir where unit tests are
                            placed (default \"tests\").
      --aux-dir=DIRECTORY   Directory relative to --dir where auxiliary build
                            tools are placed (default comes from configure.ac).
      --gnu-make            Output for GNU Make instead of for the default
                            Automake
      --lgpl[=2|=3orGPLv2|=3]
                            Abort if modules aren't available under the LGPL.
                            Also modify license template from GPL to LGPL.
                            The version number of the LGPL can be specified;
                            the default is currently LGPLv3.
      --makefile-name=NAME  Name of makefile in the source-base and tests-base
                            directories (default \"Makefile.am\", or
                            \"Makefile.in\" if --gnu-make).
      --macro-prefix=PREFIX  Specify the prefix of the macros 'gl_EARLY' and
                            'gl_INIT'. Default is 'gl'.
      --po-domain=NAME      Specify the prefix of the i18n domain. Usually use
                            the package name. A suffix '-gnulib' is appended.
      --witness-c-macro=NAME  Specify the C macro that is defined when the
                            sources in this directory are compiled or used.
      --vc-files            Update version control related files.
      --no-vc-files         Don't update version control related files
                            (.gitignore and/or .cvsignore).

Options for --create-[mega]testdir, --[mega]test:

      --single-configure    Generate a single configure file, not a separate
                            configure file for the tests directory.

Options for --import, --add/remove-import, --update,
            --create-[mega]testdir, --[mega]test:

  -s, --symbolic, --symlink Make symbolic links instead of copying files.
      --local-symlink       Make symbolic links instead of copying files, only
                            for files from the local override directory.
  -h, --hardlink            Make hard links instead of copying files.
      --local-hardlink      Make hard links instead of copying files, only
                            for files from the local override directory.

Options for --import, --add/remove-import, --update:

  -S, --more-symlinks       Make symbolic links instead of copying files, and
                            don't replace copyright notices.
  -H, --more-hardlinks      Make hard links instead of copying files, and
                            don't replace copyright notices.

Report bugs to <bug-gnulib@gnu.org>."
}

# func_version
# outputs to stdout the --version message.
func_version ()
{
  func_gnulib_dir
  if test -d "$gnulib_dir"/.git \
     && (git --version) >/dev/null 2>/dev/null \
     && (date --version) >/dev/null 2>/dev/null; then
    # gnulib checked out from git.
    sed_extract_first_date='/^Date/{
s/^Date:[        ]*//p
q
}'
    date=`cd "$gnulib_dir" && git log ChangeLog | sed -n -e "$sed_extract_first_date"`
    # Turn "Fri Mar 21 07:16:51 2008 -0600" into "Mar 21 2008 07:16:51 -0600".
    sed_year_before_time='s/^[^ ]* \([^ ]*\) \([0-9]*\) \([0-9:]*\) \([0-9]*\) /\1 \2 \4 \3 /'
    date=`echo "$date" | sed -e "$sed_year_before_time"`
    # Use GNU date to compute the time in GMT.
    date=`date -d "$date" -u +"%Y-%m-%d %H:%M:%S"`
    version=' '`cd "$gnulib_dir" && ./build-aux/git-version-gen /dev/null | sed -e 's/-dirty/-modified/'`
  else
    # gnulib copy without versioning information.
    date=`sed -e 's/ .*//;q' "$gnulib_dir"/ChangeLog`
    version=
  fi
  year=`"$gnulib_dir"/build-aux/mdate-sh "$self_abspathname" | sed -e 's,^.* ,,'`
  echo "\
gnulib-tool (GNU $package $date)$version
Copyright (C) $year Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
"
  printf "Written by %s, %s, and %s.\n" "Bruno Haible" "Paul Eggert" "Simon Josefsson"
}

# func_emit_copyright_notice
# outputs to stdout a header for a generated file.
func_emit_copyright_notice ()
{
  sed -n -e '/Copyright/ {
               p
               q
             }' < "$self_abspathname"
  echo "#"
  echo "# This file is free software; you can redistribute it and/or modify"
  echo "# it under the terms of the GNU General Public License as published by"
  echo "# the Free Software Foundation; either version 3 of the License, or"
  echo "# (at your option) any later version."
  echo "#"
  echo "# This file is distributed in the hope that it will be useful,"
  echo "# but WITHOUT ANY WARRANTY; without even the implied warranty of"
  echo "# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the"
  echo "# GNU General Public License for more details."
  echo "#"
  echo "# You should have received a copy of the GNU General Public License"
  echo "# along with this file.  If not, see <https://www.gnu.org/licenses/>."
  echo "#"
  echo "# As a special exception to the GNU General Public License,"
  echo "# this file may be distributed as part of a program that"
  echo "# contains a configuration script generated by Autoconf, under"
  echo "# the same distribution terms as the rest of that program."
  echo "#"
  echo "# Generated by gnulib-tool."
}

# func_exit STATUS
# exits with a given status.
# This function needs to be used, rather than 'exit', when a 'trap' handler is
# in effect that refers to $?.
func_exit ()
{
  (exit $1); exit $1
}

# func_gnulib_dir
# locates the directory where the gnulib repository lives
# Input:
# - progname                 name of this program
# Sets variables
# - self_abspathname         absolute pathname of gnulib-tool
# - gnulib_dir               absolute pathname of gnulib repository
func_gnulib_dir ()
{
  case "$progname" in
    /* | ?:*) self_abspathname="$progname" ;;
    */*) self_abspathname=`pwd`/"$progname" ;;
    *)
      # Look in $PATH.
      # Iterate through the elements of $PATH.
      # We use IFS=: instead of
      #   for d in `echo ":$PATH:" | sed -e 's/:::*/:.:/g' | sed -e 's/:/ /g'`
      # because the latter does not work when some PATH element contains spaces.
      # We use a canonicalized $pathx instead of $PATH, because empty PATH
      # elements are by definition equivalent to '.', however field splitting
      # according to IFS=: loses empty fields in many shells:
      #   - /bin/sh on OSF/1 and Solaris loses all empty fields (at the
      #     beginning, at the end, and in the middle),
      #   - /bin/sh on IRIX and /bin/ksh on IRIX and OSF/1 lose empty fields
      #     at the beginning and at the end,
      #   - GNU bash, /bin/sh on AIX and HP-UX, and /bin/ksh on AIX, HP-UX,
      #     Solaris lose empty fields at the end.
      # The 'case' statement is an optimization, to avoid evaluating the
      # explicit canonicalization command when $PATH contains no empty fields.
      self_abspathname=
      if test "$PATH_SEPARATOR" = ";"; then
        # On Windows, programs are searched in "." before $PATH.
        pathx=".;$PATH"
      else
        # On Unix, we have to convert empty PATH elements to ".".
        pathx="$PATH"
        case :$PATH: in
          *::*)
            pathx=`echo ":$PATH:" | sed -e 's/:::*/:.:/g' -e 's/^://' -e 's/:\$//'`
            ;;
        esac
      fi
      save_IFS="$IFS"
      IFS="$PATH_SEPARATOR"
      for d in $pathx; do
        IFS="$save_IFS"
        test -z "$d" && d=.
        if test -x "$d/$progname" && test ! -d "$d/$progname"; then
          self_abspathname="$d/$progname"
          break
        fi
      done
      IFS="$save_IFS"
      if test -z "$self_abspathname"; then
        func_fatal_error "could not locate the gnulib-tool program - how did you invoke it?"
      fi
      ;;
  esac
  while test -h "$self_abspathname"; do
    # Resolve symbolic link.
    linkval=`func_readlink "$self_abspathname"`
    test -n "$linkval" || break
    case "$linkval" in
      /* | ?:* ) self_abspathname="$linkval" ;;
      * ) self_abspathname=`echo "$self_abspathname" | sed -e 's,/[^/]*$,,'`/"$linkval" ;;
    esac
  done
  gnulib_dir=`echo "$self_abspathname" | sed -e 's,/[^/]*$,,'`
}

# func_tmpdir
# creates a temporary directory.
# Input:
# - progname                 name of this program
# Sets variable
# - tmp             pathname of freshly created temporary directory
func_tmpdir ()
{
  # Use the environment variable TMPDIR, falling back to /tmp. This allows
  # users to specify a different temporary directory, for example, if their
  # /tmp is filled up or too small.
  : ${TMPDIR=/tmp}
  {
    # Use the mktemp program if available. If not available, hide the error
    # message.
    tmp=`(umask 077 && mktemp -d "$TMPDIR/glXXXXXX") 2>/dev/null` &&
    test -n "$tmp" && test -d "$tmp"
  } ||
  {
    # Use a simple mkdir command. It is guaranteed to fail if the directory
    # already exists.  $RANDOM is bash specific and expands to empty in shells
    # other than bash, ksh and zsh.  Its use does not increase security;
    # rather, it minimizes the probability of failure in a very cluttered /tmp
    # directory.
    tmp=$TMPDIR/gl$$-$RANDOM
    (umask 077 && mkdir "$tmp")
  } ||
  {
    echo "$progname: cannot create a temporary directory in $TMPDIR" >&2
    func_exit 1
  }
}

# func_append var value
# appends the given value to the shell variable var.
if ( foo=bar; foo+=baz && test "$foo" = barbaz ) >/dev/null 2>&1; then
  # Use bash's += operator. It reduces complexity of appending repeatedly to
  # a single variable from O(n^2) to O(n).
  func_append ()
  {
    eval "$1+=\"\$2\""
  }
  fast_func_append=true
else
  func_append ()
  {
    eval "$1=\"\$$1\$2\""
  }
  fast_func_append=false
fi

# func_remove_prefix var prefix
# removes the given prefix from the value of the shell variable var.
# var should be the name of a shell variable.
# Its value should not contain a newline and not start or end with whitespace.
# prefix should not contain the characters "$`\{}[]^|.
if ( foo=bar; eval 'test "${foo#b}" = ar' ) >/dev/null 2>&1; then
  func_remove_prefix ()
  {
    eval "$1=\${$1#\$2}"
  }
  fast_func_remove_prefix=true
else
  func_remove_prefix ()
  {
    eval "value=\"\$$1\""
    prefix="$2"
    case "$prefix" in
      *.*)
        sed_escape_dots='s/\([.]\)/\\\1/g'
        prefix=`echo "$prefix" | sed -e "$sed_escape_dots"`
        ;;
    esac
    value=`echo "$value" | sed -e "s|^${prefix}||"`
    eval "$1=\"\$value\""
  }
  fast_func_remove_prefix=false
fi

# Determine whether we should use ':' or ';' as PATH_SEPARATOR.
func_determine_path_separator ()
{
  if test "${PATH_SEPARATOR+set}" != set; then
    # Determine PATH_SEPARATOR by trying to find /bin/sh in a PATH which
    # contains only /bin. Note that ksh looks also at the FPATH variable,
    # so we have to set that as well for the test.
    PATH_SEPARATOR=:
    (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \
      && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \
             || PATH_SEPARATOR=';'
         }
  fi
}

# func_path_append pathvar directory
# appends directory to pathvar, delimiting directories by PATH_SEPARATOR.
func_path_append ()
{
  if eval "test -n \"\$$1\""; then
    func_append "$1" "$PATH_SEPARATOR$2"
  else
    eval "$1=\$2"
  fi
}

# func_path_foreach_inner
# helper for func_path_foreach because we need new 'args' array
# Input:
# - fpf_dir     directory from local_gnulib_path
# - fpf_cb      callback to be run for fpf_dir
func_path_foreach_inner ()
{
  set %start% "$@"
  for _fpf_arg
  do
    case "$_fpf_arg" in
      %start%)
        set dummy
        ;;
      %dir%)
        set "$@" "$fpf_dir"
        ;;
      *)
        set "$@" "$_fpf_arg"
        ;;
    esac
  done
  shift

  "$fpf_cb" "$@"
}

# func_path_foreach path method args
# Execute method for each directory in path.  The method will be called
# like `method args` while any argument '%dir%' within args will be replaced
# with processed directory from path.
func_path_foreach ()
{
  fpf_dirs="$1"; shift
  fpf_cb="$1"; shift
  fpf_rc=false

  fpf_save_IFS="$IFS"
  IFS="$PATH_SEPARATOR"
  for fpf_dir in $fpf_dirs
  do
    IFS="$fpf_save_IFS"
    func_path_foreach_inner "$@" && fpf_rc=:
  done
  IFS="$fpf_save_IFS"
  $fpf_rc
}

# func_remove_suffix var suffix
# removes the given suffix from the value of the shell variable var.
# var should be the name of a shell variable.
# Its value should not contain a newline and not start or end with whitespace.
# suffix should not contain the characters "$`\{}[]^|.
if ( foo=bar; eval 'test "${foo%r}" = ba' ) >/dev/null 2>&1; then
  func_remove_suffix ()
  {
    eval "$1=\${$1%\$2}"
  }
  fast_func_remove_suffix=true
else
  func_remove_suffix ()
  {
    eval "value=\"\$$1\""
    suffix="$2"
    case "$suffix" in
      *.*)
        sed_escape_dots='s/\([.]\)/\\\1/g'
        suffix=`echo "$suffix" | sed -e "$sed_escape_dots"`
        ;;
    esac
    value=`echo "$value" | sed -e "s|${suffix}\$||"`
    eval "$1=\"\$value\""
  }
  fast_func_remove_suffix=false
fi

# func_fatal_error message
# outputs to stderr a fatal error message, and terminates the program.
# Input:
# - progname                 name of this program
func_fatal_error ()
{
  echo "$progname: *** $1" 1>&2
  echo "$progname: *** Stop." 1>&2
  func_exit 1
}

# func_warning message
# Outputs to stderr a warning message,
func_warning ()
{
  echo "gnulib-tool: warning: $1" 1>&2
}

# func_readlink SYMLINK
# outputs the target of the given symlink.
if (type readlink) > /dev/null 2>&1; then
  func_readlink ()
  {
    # Use the readlink program from GNU coreutils.
    readlink "$1"
  }
else
  func_readlink ()
  {
    # Use two sed invocations. A single sed -n -e 's,^.* -> \(.*\)$,\1,p'
    # would do the wrong thing if the link target contains " -> ".
    LC_ALL=C ls -l "$1" | sed -e 's, -> ,#%%#,' | sed -n -e 's,^.*#%%#\(.*\)$,\1,p'
  }
fi

# func_relativize DIR1 DIR2
# computes a relative pathname RELDIR such that DIR1/RELDIR = DIR2.
# Input:
# - DIR1            relative pathname, relative to the current directory
# - DIR2            relative pathname, relative to the current directory
# Output:
# - reldir          relative pathname of DIR2, relative to DIR1
func_relativize ()
{
  dir0=`pwd`
  dir1="$1"
  dir2="$2"
  sed_first='s,^\([^/]*\)/.*$,\1,'
  sed_rest='s,^[^/]*/*,,'
  sed_last='s,^.*/\([^/]*\)$,\1,'
  sed_butlast='s,/*[^/]*$,,'
  while test -n "$dir1"; do
    first=`echo "$dir1" | sed -e "$sed_first"`
    if test "$first" != "."; then
      if test "$first" = ".."; then
        dir2=`echo "$dir0" | sed -e "$sed_last"`/"$dir2"
        dir0=`echo "$dir0" | sed -e "$sed_butlast"`
      else
        first2=`echo "$dir2" | sed -e "$sed_first"`
        if test "$first2" = "$first"; then
          dir2=`echo "$dir2" | sed -e "$sed_rest"`
        else
          dir2="../$dir2"
        fi
        dir0="$dir0"/"$first"
      fi
    fi
    dir1=`echo "$dir1" | sed -e "$sed_rest"`
  done
  reldir="$dir2"
}

# func_relconcat DIR1 DIR2
# computes a relative pathname DIR1/DIR2, with obvious simplifications.
# Input:
# - DIR1            relative pathname, relative to the current directory
# - DIR2            relative pathname, relative to DIR1
# Output:
# - relconcat       DIR1/DIR2, relative to the current directory
func_relconcat ()
{
  dir1="$1"
  dir2="$2"
  sed_first='s,^\([^/]*\)/.*$,\1,'
  sed_rest='s,^[^/]*/*,,'
  sed_last='s,^.*/\([^/]*\)$,\1,'
  sed_butlast='s,/*[^/]*$,,'
  while true; do
    first=`echo "$dir2" | sed -e "$sed_first"`
    if test "$first" = "."; then
      dir2=`echo "$dir2" | sed -e "$sed_rest"`
      if test -z "$dir2"; then
        relconcat="$dir1"
        break
      fi
    else
      last=`echo "$dir1" | sed -e "$sed_last"`
      while test "$last" = "."; do
        dir1=`echo "$dir1" | sed -e "$sed_butlast"`
        last=`echo "$dir1" | sed -e "$sed_last"`
      done
      if test -z "$dir1"; then
        relconcat="$dir2"
        break
      fi
      if test "$first" = ".."; then
        if test "$last" = ".."; then
          relconcat="$dir1/$dir2"
          break
        fi
        dir1=`echo "$dir1" | sed -e "$sed_butlast"`
        dir2=`echo "$dir2" | sed -e "$sed_rest"`
        if test -z "$dir1"; then
          relconcat="$dir2"
          break
        fi
        if test -z "$dir2"; then
          relconcat="$dir1"
          break
        fi
      else
        relconcat="$dir1/$dir2"
        break
      fi
    fi
  done
}

# func_ensure_writable DEST
# Ensures the file DEST is writable.
func_ensure_writable ()
{
  test -w "$1" || chmod u+w "$1"
}

# func_ln_s SRC DEST
# Like ln -s, except use cp -p if ln -s fails.
func_ln_s ()
{
  ln -s "$1" "$2" || {
    echo "$progname: ln -s failed; falling back on cp -p" >&2

    case "$1" in
      /* | ?:*) # SRC is absolute.
        cp_src="$1" ;;
      *) # SRC is relative to the directory of DEST.
        case "$2" in
          */*) cp_src="${2%/*}/$1" ;;
          *)   cp_src="$1" ;;
        esac
        ;;
    esac

    cp -p "$cp_src" "$2"
    func_ensure_writable "$2"
  }
}

# func_symlink_target SRC DEST
# Determines LINK_TARGET such that "ln -s LINK_TARGET DEST" will create a
# symbolic link DEST that points to SRC.
# Output:
# - link_target     link target, relative to the directory of DEST
func_symlink_target ()
{
  case "$1" in
    /* | ?:*)
      link_target="$1" ;;
    *) # SRC is relative.
      case "$2" in
        /* | ?:*)
          link_target="`pwd`/$1" ;;
        *) # DEST is relative too.
          ln_destdir=`echo "$2" | sed -e 's,[^/]*$,,'`
          test -n "$ln_destdir" || ln_destdir="."
          func_relativize "$ln_destdir" "$1"
          link_target="$reldir"
          ;;
      esac
      ;;
  esac
}

# func_symlink SRC DEST
# Like func_ln_s, except that SRC is given relative to the current directory (or
# absolute), not given relative to the directory of DEST.
func_symlink ()
{
  func_symlink_target "$1" "$2"
  func_ln_s "$link_target" "$2"
}

# func_symlink_if_changed SRC DEST
# Like func_symlink, but avoids munging timestamps if the link is correct.
# SRC is given relative to the current directory (or absolute).
func_symlink_if_changed ()
{
  if test $# -ne 2; then
    echo "usage: func_symlink_if_changed SRC DEST" >&2
  fi
  func_symlink_target "$1" "$2"
  ln_target=`func_readlink "$2"`
  if test -h "$2" && test "$link_target" = "$ln_target"; then
    :
  else
    rm -f "$2"
    func_ln_s "$link_target" "$2"
  fi
}

# func_hardlink SRC DEST
# Like ln, except use cp -p if ln fails.
# SRC is given relative to the current directory (or absolute).
func_hardlink ()
{
  ln "$1" "$2" || {
    echo "$progname: ln failed; falling back on cp -p" >&2
    cp -p "$1" "$2"
    func_ensure_writable "$2"
  }
}

# Ensure an 'echo' command that
#   1. does not interpret backslashes and
#   2. does not print an error message "broken pipe" when writing into a pipe
#      with no writers.
#
# Test cases for problem 1:
#   echo '\n' | wc -l                 prints 1 when OK, 2 when KO
#   echo '\t' | grep t > /dev/null    has return code 0 when OK, 1 when KO
# Test cases for problem 2:
#   echo hi | true                    frequently prints
#                                     "bash: echo: write error: Broken pipe"
#                                     to standard error in bash 3.2.
#
# Problem 1 is a weird heritage from SVR4. BSD got it right (except that
# BSD echo interprets '-n' as an option, which is also not desirable).
# Nowadays the problem occurs in 4 situations:
# - in bash, when the shell option xpg_echo is set (bash >= 2.04)
#            or when it was built with --enable-usg-echo-default (bash >= 2.0)
#            or when it was built with DEFAULT_ECHO_TO_USG (bash < 2.0),
# - in zsh, when sh-emulation is not set,
# - in ksh (e.g. AIX /bin/sh and Solaris /usr/xpg4/bin/sh are ksh instances,
#           and HP-UX /bin/sh and IRIX /bin/sh behave similarly),
# - in Solaris /bin/sh and OSF/1 /bin/sh.
# We try the following workarounds:
# - for all: respawn using $CONFIG_SHELL if that is set and works.
# - for bash >= 2.04: unset the shell option xpg_echo.
# - for bash >= 2.0: define echo to a function that uses the printf built-in.
# - for bash < 2.0: define echo to a function that uses cat of a here document.
# - for zsh: turn sh-emulation on.
# - for ksh: alias echo to 'print -r'.
# - for ksh: alias echo to a function that uses cat of a here document.
# - for Solaris /bin/sh and OSF/1 /bin/sh: respawn using /bin/ksh and rely on
#   the ksh workaround.
# - otherwise: respawn using /bin/sh and rely on the workarounds.
# When respawning, we pass --no-reexec as first argument, so as to avoid
# turning this script into a fork bomb in unlucky situations.
#
# Problem 2 is specific to bash 3.2 and affects the 'echo' built-in, but not
# the 'printf' built-in. See
#   <https://lists.gnu.org/r/bug-bash/2008-12/msg00050.html>
#   <https://lists.gnu.org/r/bug-gnulib/2010-02/msg00154.html>
# The workaround is: define echo to a function that uses the printf built-in.
have_echo=
if echo '\t' | grep t > /dev/null; then
  have_echo=yes # Lucky!
fi
# Try the workarounds.
# Respawn using $CONFIG_SHELL if that is set and works.
if test -z "$have_echo" \
   && test "X$1" != "X--no-reexec" \
   && test -n "$CONFIG_SHELL" \
   && test -f "$CONFIG_SHELL" \
   && $CONFIG_SHELL -c "echo '\\t' | grep t > /dev/null"; then
  exec $CONFIG_SHELL "$0" --no-reexec "$@"
  exit 127
fi
# For bash >= 2.04: unset the shell option xpg_echo.
if test -z "$have_echo" \
   && test -n "$BASH_VERSION" \
   && (shopt -o xpg_echo; echo '\t' | grep t > /dev/null) 2>/dev/null; then
  shopt -o xpg_echo
  have_echo=yes
fi
# For bash >= 2.0: define echo to a function that uses the printf built-in.
# For bash < 2.0: define echo to a function that uses cat of a here document.
# (There is no win in using 'printf' over 'cat' if it is not a shell built-in.)
# Also handle problem 2, specific to bash 3.2, here.
if { test -z "$have_echo" \
     || case "$BASH_VERSION" in 3.2*) true;; *) false;; esac; \
   } \
   && test -n "$BASH_VERSION"; then \
  if type printf 2>/dev/null | grep / > /dev/null; then
    # 'printf' is not a shell built-in.
echo ()
{
cat <<EOF
$*
EOF
}
  else
    # 'printf' is a shell built-in.
echo ()
{
  printf '%s\n' "$*"
}
  fi
  if echo '\t' | grep t > /dev/null; then
    have_echo=yes
  fi
fi
# For zsh: turn sh-emulation on.
if test -z "$have_echo" \
   && test -n "$ZSH_VERSION" \
   && (emulate sh) >/dev/null 2>&1; then
  emulate sh
fi
# For ksh: alias echo to 'print -r'.
if test -z "$have_echo" \
   && (type print) >/dev/null 2>&1; then
  # A 'print' command exists.
  if type print 2>/dev/null | grep / > /dev/null; then
    :
  else
    # 'print' is a shell built-in.
    if (print -r '\told' | grep told > /dev/null) 2>/dev/null; then
      # 'print' is the ksh shell built-in.
      alias echo='print -r'
    fi
  fi
fi
if test -z "$have_echo" \
   && echo '\t' | grep t > /dev/null; then
  have_echo=yes
fi
# For ksh: alias echo to a function that uses cat of a here document.
# The ksh manual page says:
#   "Aliasing is performed when scripts are read, not while they are executed.
#    Therefore, for an alias to take effect, the alias definition command has
#    to be executed before the command which references the alias is read."
# Because of this, we have to play strange tricks with have_echo, to ensure
# that the top-level statement containing the test starts after the 'alias'
# command.
if test -z "$have_echo"; then
  bsd_echo ()
{
cat <<EOF
$*
EOF
}
  if (alias echo=bsd_echo) 2>/dev/null; then
    alias echo=bsd_echo 2>/dev/null
  fi
fi
if test -z "$have_echo" \
   && echo '\t' | grep t > /dev/null; then
  have_echo=yes
fi
if test -z "$have_echo"; then
  if (alias echo=bsd_echo) 2>/dev/null; then
    unalias echo 2>/dev/null
  fi
fi
# For Solaris /bin/sh and OSF/1 /bin/sh: respawn using /bin/ksh.
if test -z "$have_echo" \
   && test "X$1" != "X--no-reexec" \
   && test -f /bin/ksh; then
  exec /bin/ksh "$0" --no-reexec "$@"
  exit 127
fi
# Otherwise: respawn using /bin/sh.
if test -z "$have_echo" \
   && test "X$1" != "X--no-reexec" \
   && test -f /bin/sh; then
  exec /bin/sh "$0" --no-reexec "$@"
  exit 127
fi
if test -z "$have_echo"; then
  func_fatal_error "Shell does not support 'echo' correctly. Please install GNU bash and set the environment variable CONFIG_SHELL to point to it."
fi
if echo '\t' | grep t > /dev/null; then
  : # Works fine now.
else
  func_fatal_error "Shell does not support 'echo' correctly. Workaround does not work. Please report this as a bug to bug-gnulib@gnu.org."
fi
if test "X$1" = "X--no-reexec"; then
  shift
fi

# Unset CDPATH.  Otherwise, output from 'cd dir' can surprise callers.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

# Determine the path separator early because the following option parsing code
# requires that.
func_determine_path_separator

# Command-line option processing.
# Removes the OPTIONS from the arguments. Sets the variables:
# - mode            one of: list, find, import, add-import, remove-import,
#                   update, create-testdir, create-megatestdir, test, megatest,
#                   copy-file
# - destdir         from --dir
# - local_gnulib_path  from --local-dir, highest priority dir comes first
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - verbose         integer, default 0, inc/decremented by --verbose/--quiet
# - libname, supplied_libname  from --lib
# - sourcebase      from --source-base
# - m4base          from --m4-base
# - pobase          from --po-base
# - docbase         from --doc-base
# - testsbase       from --tests-base
# - auxdir          from --aux-dir
# - inctests        true if --with-tests was given, false if --without-tests
#                   was given, blank otherwise
# - incobsolete     true if --with-obsolete was given, blank otherwise
# - inc_cxx_tests   true if --with-c++-tests was given, blank otherwise
# - inc_longrunning_tests  true if --with-longrunning-tests was given, blank
#                          otherwise
# - inc_privileged_tests  true if --with-privileged-tests was given, blank
#                         otherwise
# - inc_unportable_tests  true if --with-unportable-tests was given, blank
#                         otherwise
# - inc_all_tests   true if --with-all-tests was given, blank otherwise
# - excl_cxx_tests  true if --without-c++-tests was given, blank otherwise
# - excl_longrunning_tests  true if --without-longrunning-tests was given,
#                           blank otherwise
# - excl_privileged_tests  true if --without-privileged-tests was given, blank
#                          otherwise
# - excl_unportable_tests  true if --without-unportable-tests was given, blank
#                          otherwise
# - single_configure  true if --single-configure was given, false otherwise
# - avoidlist       list of modules to avoid, from --avoid
# - cond_dependencies  true if --conditional-dependencies was given, false if
#                      --no-conditional-dependencies was given, blank otherwise
# - lgpl            yes or a number if --lgpl was given, blank otherwise
# - gnu_make        true if --gnu-make was given, false otherwise
# - makefile_name   from --makefile-name
# - libtool         true if --libtool was given, false if --no-libtool was
#                   given, blank otherwise
# - macro_prefix    from --macro-prefix
# - po_domain       from --po-domain
# - witness_c_macro  from --witness-c-macro
# - vc_files        true if --vc-files was given, false if --no-vc-files was
#                   given, blank otherwise
# - autoconf_minversion  minimum supported autoconf version
# - doit            : if actions shall be executed, false if only to be printed
# - copymode        symlink if --symlink or --more-symlinks was given,
#                   hardlink if --hardlink or --more-hardlinks was given,
#                   blank otherwise
# - lcopymode       symlink if --local-symlink was given,
#                   hardlink if --local-hardlink was given,
#                   blank otherwise
# - do_copyrights   blank if --more-symlinks or --more-hardlinks was given,
#                   true otherwise
{
  mode=
  destdir=
  local_gnulib_path=
  modcache=true
  verbose=0
  libname=libgnu
  supplied_libname=
  sourcebase=
  m4base=
  pobase=
  docbase=
  testsbase=
  auxdir=
  inctests=
  incobsolete=
  inc_cxx_tests=
  inc_longrunning_tests=
  inc_privileged_tests=
  inc_unportable_tests=
  inc_all_tests=
  excl_cxx_tests=
  excl_longrunning_tests=
  excl_privileged_tests=
  excl_unportable_tests=
  single_configure=false
  avoidlist=
  cond_dependencies=
  lgpl=
  gnu_make=false
  makefile_name=
  libtool=
  macro_prefix=
  po_domain=
  witness_c_macro=
  vc_files=
  doit=:
  copymode=
  lcopymode=
  do_copyrights=true

  supplied_opts="$@"

  while test $# -gt 0; do
    case "$1" in
      --list | --lis )
        mode=list
        shift ;;
      --find | --fin | --fi | --f )
        mode=find
        shift ;;
      --import | --impor | --impo | --imp | --im | --i )
        mode=import
        shift ;;
      --add-import | --add-impor | --add-impo | --add-imp | --add-im | --add-i | --add- | --add | --ad )
        mode=add-import
        shift ;;
      --remove-import | --remove-impor | --remove-impo | --remove-imp | --remove-im | --remove-i | --remove- | --remove | --remov | --remo | --rem | --re | --r )
        mode=remove-import
        shift ;;
      --update | --updat | --upda | --upd | --up | --u )
        mode=update
        shift ;;
      --create-testdir | --create-testdi | --create-testd | --create-test | --create-tes | --create-te | --create-t )
        mode=create-testdir
        shift ;;
      --create-megatestdir | --create-megatestdi | --create-megatestd | --create-megatest | --create-megates | --create-megate | --create-megat | --create-mega | --create-meg | --create-me | --create-m )
        mode=create-megatestdir
        shift ;;
      --test | --tes | --te | --t )
        mode=test
        shift ;;
      --megatest | --megates | --megate | --megat | --mega | --meg | --me | --m )
        mode=megatest
        shift ;;
      --extract-* )
        mode=`echo "X$1" | sed -e 's/^X--//'`
        shift ;;
      --copy-file | --copy-fil | --copy-fi | --copy-f | --copy- | --copy | --cop )
        mode=copy-file
        shift ;;
      --dir )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --dir"
        fi
        destdir=$1
        shift ;;
      --dir=* )
        destdir=`echo "X$1" | sed -e 's/^X--dir=//'`
        shift ;;
      --local-dir )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --local-dir"
        fi
        func_path_append local_gnulib_path "$1"
        shift ;;
      --local-dir=* )
        local_dir=`echo "X$1" | sed -e 's/^X--local-dir=//'`
        func_path_append local_gnulib_path "$local_dir"
        shift ;;
      --cache-modules | --cache-module | --cache-modul | --cache-modu | --cache-mod | --cache-mo | --cache-m | --cache- | --cache | --cach | --cac | --ca )
        modcache=true
        shift ;;
      --no-cache-modules | --no-cache-module | --no-cache-modul | --no-cache-modu | --no-cache-mod | --no-cache-mo | --no-cache-m | --no-cache- | --no-cache | --no-cach | --no-cac | --no-ca )
        modcache=false
        shift ;;
      --verbose | --verbos | --verbo | --verb )
        verbose=`expr $verbose + 1`
        shift ;;
      --quiet | --quie | --qui | --qu | --q )
        verbose=`expr $verbose - 1`
        shift ;;
      --lib )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --lib"
        fi
        libname=$1
        supplied_libname=true
        shift ;;
      --lib=* )
        libname=`echo "X$1" | sed -e 's/^X--lib=//'`
        supplied_libname=true
        shift ;;
      --source-base )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --source-base"
        fi
        sourcebase=$1
        shift ;;
      --source-base=* )
        sourcebase=`echo "X$1" | sed -e 's/^X--source-base=//'`
        shift ;;
      --m4-base )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --m4-base"
        fi
        m4base=$1
        shift ;;
      --m4-base=* )
        m4base=`echo "X$1" | sed -e 's/^X--m4-base=//'`
        shift ;;
      --po-base )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --po-base"
        fi
        pobase=$1
        shift ;;
      --po-base=* )
        pobase=`echo "X$1" | sed -e 's/^X--po-base=//'`
        shift ;;
      --doc-base )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --doc-base"
        fi
        docbase=$1
        shift ;;
      --doc-base=* )
        docbase=`echo "X$1" | sed -e 's/^X--doc-base=//'`
        shift ;;
      --tests-base )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --tests-base"
        fi
        testsbase=$1
        shift ;;
      --tests-base=* )
        testsbase=`echo "X$1" | sed -e 's/^X--tests-base=//'`
        shift ;;
      --aux-dir )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --aux-dir"
        fi
        auxdir=$1
        shift ;;
      --aux-dir=* )
        auxdir=`echo "X$1" | sed -e 's/^X--aux-dir=//'`
        shift ;;
      --with-tests | --with-test | --with-tes | --with-te | --with-t)
        inctests=true
        shift ;;
      --with-obsolete | --with-obsolet | --with-obsole | --with-obsol | --with-obso | --with-obs | --with-ob | --with-o)
        incobsolete=true
        shift ;;
      --with-c++-tests | --with-c++-test | --with-c++-tes | --with-c++-te | --with-c++-t | --with-c++- | --with-c++ | --with-c+ | --with-c)
        inc_cxx_tests=true
        shift ;;
      --with-longrunning-tests | --with-longrunning-test | --with-longrunning-tes | --with-longrunning-te | --with-longrunning-t | --with-longrunning- | --with-longrunning | --with-longrunnin | --with-longrunni | --with-longrunn | --with-longrun | --with-longru | --with-longr | --with-long | --with-lon | --with-lo | --with-l)
        inc_longrunning_tests=true
        shift ;;
      --with-privileged-tests | --with-privileged-test | --with-privileged-tes | --with-privileged-te | --with-privileged-t | --with-privileged- | --with-privileged | --with-privilege | --with-privileg | --with-privile | --with-privil | --with-privi | --with-priv | --with-pri | --with-pr | --with-p)
        inc_privileged_tests=true
        shift ;;
      --with-unportable-tests | --with-unportable-test | --with-unportable-tes | --with-unportable-te | --with-unportable-t | --with-unportable- | --with-unportable | --with-unportabl | --with-unportab | --with-unporta | --with-unport | --with-unpor | --with-unpo | --with-unp | --with-un | --with-u)
        inc_unportable_tests=true
        shift ;;
      --with-all-tests | --with-all-test | --with-all-tes | --with-all-te | --with-all-t | --with-all- | --with-all | --with-al | --with-a)
        inc_all_tests=true
        shift ;;
      --without-tests | --without-test | --without-tes | --without-te | --without-t)
        inctests=false
        shift ;;
      --without-c++-tests | --without-c++-test | --without-c++-tes | --without-c++-te | --without-c++-t | --without-c++- | --without-c++ | --without-c+ | --without-c)
        excl_cxx_tests=true
        shift ;;
      --without-longrunning-tests | --without-longrunning-test | --without-longrunning-tes | --without-longrunning-te | --without-longrunning-t | --without-longrunning- | --without-longrunning | --without-longrunnin | --without-longrunni | --without-longrunn | --without-longrun | --without-longru | --without-longr | --without-long | --without-lon | --without-lo | --without-l)
        excl_longrunning_tests=true
        shift ;;
      --without-privileged-tests | --without-privileged-test | --without-privileged-tes | --without-privileged-te | --without-privileged-t | --without-privileged- | --without-privileged | --without-privilege | --without-privileg | --without-privile | --without-privil | --without-privi | --without-priv | --without-pri | --without-pr | --without-p)
        excl_privileged_tests=true
        shift ;;
      --without-unportable-tests | --without-unportable-test | --without-unportable-tes | --without-unportable-te | --without-unportable-t | --without-unportable- | --without-unportable | --without-unportabl | --without-unportab | --without-unporta | --without-unport | --without-unpor | --without-unpo | --without-unp | --without-un | --without-u)
        excl_unportable_tests=true
        shift ;;
      --single-configure | --single-configur | --single-configu | --single-config | --single-confi | --single-conf | --single-con | --single-con | --single-co | --single-c | --single- | --single | --singl | --sing | --sin | --si)
        single_configure=true
        shift ;;
      --avoid )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --avoid"
        fi
        func_append avoidlist " $1"
        shift ;;
      --avoid=* )
        arg=`echo "X$1" | sed -e 's/^X--avoid=//'`
        func_append avoidlist " $arg"
        shift ;;
      --conditional-dependencies | --conditional-dependencie | --conditional-dependenci | --conditional-dependenc | --conditional-dependen | --conditional-depende | --conditional-depend | --conditional-depen | --conditional-depe | --conditional-dep | --conditional-de | --conditional-d | --conditional- | --conditional | --conditiona | --condition | --conditio | --conditi | --condit | --condi | --cond | --con)
        cond_dependencies=true
        shift ;;
      --no-conditional-dependencies | --no-conditional-dependencie | --no-conditional-dependenci | --no-conditional-dependenc | --no-conditional-dependen | --no-conditional-depende | --no-conditional-depend | --no-conditional-depen | --no-conditional-depe | --no-conditional-dep | --no-conditional-de | --no-conditional-d | --no-conditional- | --no-conditional | --no-conditiona | --no-condition | --no-conditio | --no-conditi | --no-condit | --no-condi | --no-cond | --no-con | --no-co)
        cond_dependencies=false
        shift ;;
      --lgpl )
        lgpl=yes
        shift ;;
      --lgpl=* )
        arg=`echo "X$1" | sed -e 's/^X--lgpl=//'`
        case "$arg" in
          2 | 3orGPLv2 | 3) ;;
          *) func_fatal_error "invalid LGPL version number for --lgpl" ;;
        esac
        lgpl=$arg
        shift ;;
      --gnu-make )
        gnu_make=true
        shift ;;
      --makefile-name )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --makefile-name"
        fi
        makefile_name="$1"
        shift ;;
      --makefile-name=* )
        makefile_name=`echo "X$1" | sed -e 's/^X--makefile-name=//'`
        shift ;;
      --libtool )
        libtool=true
        shift ;;
      --no-libtool )
        libtool=false
        shift ;;
      --macro-prefix )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --macro-prefix"
        fi
        macro_prefix="$1"
        shift ;;
      --macro-prefix=* )
        macro_prefix=`echo "X$1" | sed -e 's/^X--macro-prefix=//'`
        shift ;;
      --po-domain )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --po-domain"
        fi
        po_domain="$1"
        shift ;;
      --po-domain=* )
        po_domain=`echo "X$1" | sed -e 's/^X--po-domain=//'`
        shift ;;
      --witness-c-macro )
        shift
        if test $# = 0; then
          func_fatal_error "missing argument for --witness-c-macro"
        fi
        witness_c_macro="$1"
        shift ;;
      --witness-c-macro=* )
        witness_c_macro=`echo "X$1" | sed -e 's/^X--witness-c-macro=//'`
        shift ;;
      --vc-files )
        vc_files=true
        shift ;;
      --no-vc-files )
        vc_files=false
        shift ;;
      --no-changelog | --no-changelo | --no-changel | --no-change | --no-chang | --no-chan | --no-cha | --no-ch )
        # A no-op for backward compatibility.
        shift ;;
      --dry-run )
        doit=false
        shift ;;
      -s | --symbolic | --symboli | --symbol | --symbo | --symb | --symlink | --symlin | --symli | --syml | --sym | --sy )
        copymode=symlink
        shift ;;
      --local-symlink | --local-symlin | --local-symli | --local-syml | --local-sym | --local-sy | --local-s )
        lcopymode=symlink
        shift ;;
      -h | --hardlink | --hardlin | --hardli | --hardl | --hard | --har | --ha )
        copymode=hardlink
        shift ;;
      --local-hardlink | --local-hardlin | --local-hardli | --local-hardl | --local-hard | --local-har | --local-ha | --local-h )
        lcopymode=hardlink
        shift ;;
      -S | --more-symlinks | --more-symlink | --more-symlin | --more-symli | --more-syml | --more-sym | --more-sy | --more-s )
        copymode=symlink
        do_copyrights=
        shift ;;
      -H | --more-hardlinks | --more-hardlink | --more-hardlin | --more-hardli | --more-hardl | --more-hard | --more-har | --more-ha | --more-h )
        copymode=hardlink
        do_copyrights=
        shift ;;
      --help | --hel | --he )
        func_usage
        func_exit $? ;;
      --version | --versio | --versi | --vers )
        func_version
        func_exit $? ;;
      -- )
        # Stop option processing
        shift
        break ;;
      -* )
        echo "gnulib-tool: unknown option $1" 1>&2
        echo "Try 'gnulib-tool --help' for more information." 1>&2
        func_exit 1 ;;
      * )
        break ;;
    esac
  done

  if case "$mode" in import | add-import | remove-import) true;; *) false;; esac; then
    if test -n "$excl_cxx_tests" || test -n "$excl_longrunning_tests" \
       || test -n "$excl_privileged_tests" || test -n "$excl_unportable_tests" \
       || test "$single_configure" != false; then
      echo "gnulib-tool: invalid options for '$mode' mode" 1>&2
      echo "Try 'gnulib-tool --help' for more information." 1>&2
      func_exit 1
    fi
  fi
  if test "$mode" = update; then
    if test $# != 0; then
      echo "gnulib-tool: too many arguments in 'update' mode" 1>&2
      echo "Try 'gnulib-tool --help' for more information." 1>&2
      echo "If you really want to modify the gnulib configuration of your project," 1>&2
      echo "you need to use 'gnulib --import' - at your own risk!" 1>&2
      func_exit 1
    fi
    if test -n "$local_gnulib_path" || test -n "$supplied_libname" \
       || test -n "$sourcebase" || test -n "$m4base" || test -n "$pobase" \
       || test -n "$docbase" || test -n "$testsbase" || test -n "$auxdir" \
       || test -n "$inctests" || test -n "$incobsolete" \
       || test -n "$inc_cxx_tests" || test -n "$inc_longrunning_tests" \
       || test -n "$inc_privileged_tests" || test -n "$inc_unportable_tests" \
       || test -n "$inc_all_tests" \
       || test -n "$excl_cxx_tests" || test -n "$excl_longrunning_tests" \
       || test -n "$excl_privileged_tests" || test -n "$excl_unportable_tests" \
       || test -n "$avoidlist" || test -n "$lgpl" || test -n "$makefile_name" \
       || test -n "$macro_prefix" || test -n "$po_domain" \
       || test -n "$witness_c_macro" || test -n "$vc_files"; then
      echo "gnulib-tool: invalid options for 'update' mode" 1>&2
      echo "Try 'gnulib-tool --help' for more information." 1>&2
      echo "If you really want to modify the gnulib configuration of your project," 1>&2
      echo "you need to use 'gnulib --import' - at your own risk!" 1>&2
      func_exit 1
    fi
  fi
  if test -n "$pobase" && test -z "$po_domain"; then
    echo "gnulib-tool: together with --po-base, you need to specify --po-domain" 1>&2
    echo "Try 'gnulib-tool --help' for more information." 1>&2
    func_exit 1
  fi
  if test -z "$pobase" && test -n "$po_domain"; then
    func_warning "--po-domain has no effect without a --po-base option"
  fi
  case $mode,$gnu_make in
    *test*,true)
      echo "gnulib-tool: --gnu-make not supported when including tests"
      func_exit 1;;
  esac
  # Canonicalize the inctests variable.
  case "$mode" in
    import | add-import | remove-import | update)
      if test -z "$inctests"; then
        inctests=false
      fi
      ;;
    create-testdir | create-megatestdir | test | megatest)
      if test -z "$inctests"; then
        inctests=true
      fi
      ;;
  esac
  # Now the only possible values of "$inctests" are true and false
  # (or blank but then it is irrelevant).

  # Determine the minimum supported autoconf version from the project's
  # configure.ac.
  DEFAULT_AUTOCONF_MINVERSION="2.64"
  autoconf_minversion=
  configure_ac=
  if case "$mode" in import | add-import | remove-import | update) true;; *) false;; esac \
     && test -n "$destdir"; then
    if test -f "$destdir"/configure.ac; then
      configure_ac="$destdir/configure.ac"
    else
      if test -f "$destdir"/configure.in; then
        configure_ac="$destdir/configure.in"
      fi
    fi
  else
    if test -f configure.ac; then
      configure_ac="configure.ac"
    else
      if test -f configure.in; then
        configure_ac="configure.in"
      fi
    fi
  fi
  if test -n "$configure_ac"; then
    # Use sed, not autoconf --trace, to look for the AC_PREREQ invocation,
    # because when some m4 files are omitted from a version control repository,
    # "autoconf --trace=AC_PREREQ" fails with an error message like this:
    #   m4: aclocal.m4:851: Cannot open m4/absolute-header.m4: No such file or directory
    #   autom4te: m4 failed with exit status: 1
    prereqs=
    my_sed_traces='
      s,#.*$,,
      s,^dnl .*$,,
      s, dnl .*$,,
      /AC_PREREQ/ {
        s,^.*AC_PREREQ([[ ]*\([^])]*\).*$,\1,p
      }'
    prereqs=`sed -n -e "$my_sed_traces" < "$configure_ac"`
    if test -n "$prereqs"; then
      autoconf_minversion=`
        for version in $prereqs; do echo $version; done |
        LC_ALL=C sort -nru | sed -e 1q
      `
    fi
  fi
  if test -z "$autoconf_minversion"; then
    autoconf_minversion=$DEFAULT_AUTOCONF_MINVERSION
  fi
  case "$autoconf_minversion" in
    1.* | 2.[0-5]* | 2.6[0-3]*)
      func_fatal_error "minimum supported autoconf version is 2.64. Try adding AC_PREREQ([$DEFAULT_AUTOCONF_MINVERSION]) to your configure.ac." ;;
  esac

  # Remove trailing slashes from the directory names. This is necessary for
  # m4base (to avoid an error in func_import) and optional for the others.
  sed_trimtrailingslashes='s,\([^/]\)//*$,\1,'
  old_local_gnulib_path="$local_gnulib_path"
  local_gnulib_path=
  save_IFS="$IFS"
  IFS=:
  for dir in $old_local_gnulib_path
  do
    IFS="$save_IFS"
    case "$dir" in
      */ ) dir=`echo "$dir" | sed -e "$sed_trimtrailingslashes"` ;;
    esac
    func_path_append local_gnulib_path "$dir"
  done
  IFS="$save_IFS"
  case "$sourcebase" in
    */ ) sourcebase=`echo "$sourcebase" | sed -e "$sed_trimtrailingslashes"` ;;
  esac
  case "$m4base" in
    */ ) m4base=`echo "$m4base" | sed -e "$sed_trimtrailingslashes"` ;;
  esac
  case "$pobase" in
    */ ) pobase=`echo "$pobase" | sed -e "$sed_trimtrailingslashes"` ;;
  esac
  case "$docbase" in
    */ ) docbase=`echo "$docbase" | sed -e "$sed_trimtrailingslashes"` ;;
  esac
  case "$testsbase" in
    */ ) testsbase=`echo "$testsbase" | sed -e "$sed_trimtrailingslashes"` ;;
  esac
  case "$auxdir" in
    */ ) auxdir=`echo "$auxdir" | sed -e "$sed_trimtrailingslashes"` ;;
  esac
}

func_gnulib_dir
func_tmpdir
trap 'exit_status=$?
      if test "$signal" != 0; then
        echo "caught signal $signal" >&2
      fi
      rm -rf "$tmp"
      exit $exit_status' 0
for signal in 1 2 3 13 15; do
  trap '{ signal='$signal'; func_exit 1; }' $signal
done
signal=0

# Note: The 'eval' silences stderr output in dash.
if (declare -A x && { x[f/2]='foo'; x[f/3]='bar'; eval test '${x[f/2]}' = foo; }) 2>/dev/null; then
  # Zsh 4 and Bash 4 have associative arrays.
  have_associative=true
else
  # For other shells, use 'eval' with computed shell variable names.
  have_associative=false
fi

# func_lookup_local_file_cb dir file
# returns true and sets func_lookup_local_file_result if the file $dir/$file
# exists.
func_lookup_local_file_cb ()
{
  test -n "$func_lookup_local_file_result" && return 1 # already found?
  test -f "$1/$2" || return 1
  func_lookup_local_file_result=$1/$2
  :
}

# func_lookup_local_file file
# looks up a file in $local_gnulib_path.
# Input:
# - local_gnulib_path  from --local-dir
# Output:
# - func_lookup_local_file_result  name of the file, valid only when the
#                   function succeeded.
func_lookup_local_file ()
{
  func_lookup_local_file_result=
  func_path_foreach "$local_gnulib_path" func_lookup_local_file_cb %dir% "$1"
}

# func_lookup_file_cb dir
# does one step in processing the $local_gnulib_path, looking for $dir/$lkfile
# and $dir/$lkfile.diff.
func_lookup_file_cb ()
{
  # If we found the file already in a --local-dir of higher priority, nothing
  # more to do.
  if test -z "$lookedup_file"; then
    # Otherwise, look for $dir/$lkfile and $dir/$lkfile.diff.
    if test -f "$1/$lkfile"; then
      lookedup_file="$1/$lkfile"
    else
      if test -f "$1/$lkfile.diff"; then
        lkpatches="$1/$lkfile.diff${lkpatches:+$PATH_SEPARATOR$lkpatches}"
      fi
    fi
  fi
}

# func_lookup_file file
# looks up a file in $local_gnulib_path or $gnulib_dir, or combines it through
# 'patch'.
# Input:
# - local_gnulib_path  from --local-dir
# Output:
# - lookedup_file   name of the merged (combined) file
# - lookedup_tmp    true if it is located in the tmp directory, blank otherwise
func_lookup_file ()
{
  lkfile="$1"
  # Each element in $local_gnulib_path is a directory whose contents overrides
  # or amends the result of the lookup in the rest of $local_gnulib_path and
  # $gnulib_dir. So, the first element of $local_gnulib_path is the highest
  # priority one.
  lookedup_file=
  lkpatches=
  func_path_foreach "$local_gnulib_path" func_lookup_file_cb %dir%
  # Treat $gnulib_dir like a lowest-priority --local-dir, except that here we
  # don't look for .diff files.
  if test -z "$lookedup_file"; then
    if test -f "$gnulib_dir/$lkfile"; then
      lookedup_file="$gnulib_dir/$lkfile"
    else
      func_fatal_error "file $gnulib_dir/$lkfile not found"
    fi
  fi
  # Now apply the patches, from lowest-priority to highest-priority.
  lookedup_tmp=
  if test -n "$lkpatches"; then
    lkbase=`echo "$lkfile" | sed -e 's,^.*/,,'`
    rm -f "$tmp/$lkbase"
    cp "$lookedup_file" "$tmp/$lkbase"
    func_ensure_writable "$tmp/$lkbase"
    save_IFS="$IFS"
    IFS="$PATH_SEPARATOR"
    for patchfile in $lkpatches; do
      IFS="$save_IFS"
      patch -s "$tmp/$lkbase" < "$patchfile" >&2 \
        || func_fatal_error "patch file $patchfile didn't apply cleanly"
    done
    IFS="$save_IFS"
    lookedup_file="$tmp/$lkbase"
    lookedup_tmp=true
  fi
}

# func_sanitize_modulelist
# receives a list of possible module names on standard input, one per line.
# It removes those which are just file names unrelated to modules, and outputs
# the resulting list to standard output, one per line.
func_sanitize_modulelist ()
{
  sed -e '/^ChangeLog$/d' -e '/\/ChangeLog$/d' \
      -e '/^COPYING$/d' -e '/\/COPYING$/d' \
      -e '/^README$/d' -e '/\/README$/d' \
      -e '/^TEMPLATE$/d' \
      -e '/^TEMPLATE-EXTENDED$/d' \
      -e '/^TEMPLATE-TESTS$/d' \
      -e '/^\..*/d' \
      -e '/~$/d'
}


# func_modules_in_dir dir
# outputs all module files in dir to standard output.
func_modules_in_dir ()
{
  (test -d "$1" && cd "$1" && find modules -type f -print)
}

# func_all_modules
# Input:
# - local_gnulib_path  from --local-dir
func_all_modules ()
{
  # Filter out metainformation files like README, which are not modules.
  # Filter out unit test modules; they can be retrieved through
  # --extract-tests-module if desired.
  {
    (cd "$gnulib_dir" && find modules -type f -print | sed -e 's,^modules/,,')
    func_path_foreach "$local_gnulib_path" func_modules_in_dir %dir% | sed -e 's,^modules/,,' -e 's,\.diff$,,'
  } \
      | func_sanitize_modulelist \
      | sed -e '/-tests$/d' \
      | LC_ALL=C sort -u
}

# func_exists_local_module dir module
# returns true if module exists in dir
func_exists_local_module ()
{
    test -d "$1/modules" && test -f "$1/modules/$2";
}

# func_exists_module module
# tests whether a module, given by name, exists
# Input:
# - local_gnulib_path  from --local-dir
func_exists_module ()
{
  { test -f "$gnulib_dir/modules/$1" \
    || func_path_foreach "$local_gnulib_path" func_exists_local_module %dir% "$1" ; } \
  && test "ChangeLog" != "$1" \
  && test "COPYING" != "$1" \
  && test "README" != "$1" \
  && test "TEMPLATE" != "$1" \
  && test "TEMPLATE-EXTENDED" != "$1" \
  && test "TEMPLATE-TESTS" != "$1"
}

# func_verify_module
# verifies a module name
# Input:
# - local_gnulib_path  from --local-dir
# - module          module name argument
# Output:
# - module          unchanged if OK, empty if not OK
# - lookedup_file   if OK: name of the merged (combined) module description file
# - lookedup_tmp    if OK: true if it is located in the tmp directory, blank otherwise
func_verify_module ()
{
  if func_exists_module "$module"; then
    # OK, $module is a correct module name.
    # Verify that building the module description with 'patch' succeeds.
    func_lookup_file "modules/$module"
  else
    func_warning "module $module doesn't exist"
    module=
  fi
}

# func_verify_nontests_module
# verifies a module name, excluding tests modules
# Input:
# - local_gnulib_path  from --local-dir
# - module          module name argument
func_verify_nontests_module ()
{
  case "$module" in
    *-tests ) module= ;;
    * ) func_verify_module ;;
  esac
}

# func_verify_tests_module
# verifies a module name, considering only tests modules
# Input:
# - local_gnulib_path  from --local-dir
# - module          module name argument
func_verify_tests_module ()
{
  case "$module" in
    *-tests ) func_verify_module ;;
    * ) module= ;;
  esac
}

# Suffix of a sed expression that extracts a particular field from a
# module description.
# A field starts with a line that contains a keyword, such as 'Description',
# followed by a colon and optional whitespace. All following lines, up to
# the next field (or end of file if there is none) form the contents of the
# field.
# An absent field is equivalent to a field with empty contents.
# NOTE: Keep this in sync with sed_extract_cache_prog below!
sed_extract_prog=':[     ]*$/ {
  :a
    n
    s/^Description:[     ]*$//
    s/^Comment:[         ]*$//
    s/^Status:[  ]*$//
    s/^Notice:[  ]*$//
    s/^Applicability:[   ]*$//
    s/^Files:[   ]*$//
    s/^Depends-on:[      ]*$//
    s/^configure\.ac-early:[     ]*$//
    s/^configure\.ac:[   ]*$//
    s/^Makefile\.am:[    ]*$//
    s/^Include:[         ]*$//
    s/^Link:[    ]*$//
    s/^License:[         ]*$//
    s/^Maintainer:[      ]*$//
    tb
    p
    ba
  :b
}'

# Piece of a sed expression that converts a field header line to a shell
# variable name,
# NOTE: Keep this in sync with sed_extract_prog above!
sed_extract_field_header='
  s/^Description:[       ]*$/description/
  s/^Comment:[   ]*$/comment/
  s/^Status:[    ]*$/status/
  s/^Notice:[    ]*$/notice/
  s/^Applicability:[     ]*$/applicability/
  s/^Files:[     ]*$/files/
  s/^Depends-on:[        ]*$/dependson/
  s/^configure\.ac-early:[       ]*$/configureac_early/
  s/^configure\.ac:[     ]*$/configureac/
  s/^Makefile\.am:[      ]*$/makefile/
  s/^Include:[   ]*$/include/
  s/^Link:[      ]*$/link/
  s/^License:[   ]*$/license/
  s/^Maintainer:[        ]*$/maintainer/'

if $modcache; then

  if $have_associative; then

    # Declare the associative arrays.
    declare -A modcache_cached
    sed_to_declare_statement='s|^.*/\([a-zA-Z0-9_]*\)/$|declare -A modcache_\1|p'
    declare_script=`echo "$sed_extract_field_header" | sed -n -e "$sed_to_declare_statement"`
    eval "$declare_script"

  else

    # func_cache_var module
    # computes the cache variable name corresponding to $module.
    # Note: This computation can map different module names to the same
    # cachevar (such as 'foo-bar', 'foo_bar', or 'foo/bar'); the caller has
    # to protect against this case.
    # Output:
    # - cachevar               a shell variable name
    if (f=foo; eval echo '${f//o/e}') < /dev/null 2>/dev/null | grep fee >/dev/null; then
      # Bash 2.0 and newer, ksh, and zsh support the syntax
      #   ${param//pattern/replacement}
      # as a shorthand for
      #   `echo "$param" | sed -e "s/pattern/replacement/g"`.
      # Note: The 'eval' is necessary for dash and NetBSD /bin/sh.
      eval 'func_cache_var ()
      {
        cachevar=c_${1//[!a-zA-Z0-9_]/_}
      }'
    else
      func_cache_var ()
      {
        case $1 in
          *[!a-zA-Z0-9_]*)
            cachevar=c_`echo "$1" | LC_ALL=C sed -e 's/[^a-zA-Z0-9_]/_/g'` ;;
          *)
            cachevar=c_$1 ;;
        esac
      }
    fi

  fi

  # func_init_sed_convert_to_cache_statements
  # Input:
  # - modcachevar_assignment
  # Output:
  # - sed_convert_to_cache_statements
  func_init_sed_convert_to_cache_statements ()
  {
    # 'sed' script that turns a module description into shell script
    # assignments, suitable to be eval'ed.  All active characters are escaped.
    # This script turns
    #   Description:
    #   Some module's description
    #
    #   Files:
    #   lib/file.h
    # into:
    #   modcache_description[$1]=\
    #   'Some module'"'"'s description
    #   '
    #   modcache_files[$1]=\
    #   'lib/file.h'
    # or:
    #   c_MODULE_description_set=set; c_MODULE_description=\
    #   'Some module'"'"'s description
    #   '
    #   c_MODULE_files_set=set; c_MODULE_files=\
    #   'lib/file.h'
    # The script consists of two parts:
    # 1) Ignore the lines before the first field header.
    # 2) A loop, treating non-field-header lines by escaping single quotes
    #    and adding a closing quote in the last line,
    sed_convert_to_cache_statements="
      :llla
        # Here we have not yet seen a field header.

        # See if the current line contains a field header.
        t llla1
        :llla1
        ${sed_extract_field_header}
        t lllb

        # No field header. Ignore the line.

        # Read the next line. Upon EOF, just exit.
        n
      b llla

      :lllb
        # The current line contains a field header.

        # Turn it into the beginning of an assignment.
        s/^\\(.*\\)\$/${modcachevar_assignment}\\\\/

        # Move it to the hold space. Don't print it yet,
        # because we want no assignment if the field is empty.
        h

        # Read the next line.
        # Upon EOF, the field was empty. Print no assignment. Just exit.
        n

        # See if the current line contains a field header.
        t lllb1
        :lllb1
        ${sed_extract_field_header}
        # If it is, the previous field was empty. Print no assignment.
        t lllb

        # Not a field header.

        # Print the previous line, held in the hold space.
        x
        p
        x

        # Transform single quotes.
        s/'/'\"'\"'/g

        # Prepend a single quote.
        s/^/'/

        :lllc

          # Move it to the hold space.
          h

          # Read the next line.
          # Upon EOF, branch.
          \${
            b llle
          }
          n

          # See if the current line contains a field header.
          t lllc1
          :lllc1
          ${sed_extract_field_header}
          t llld

          # Print the previous line, held in the hold space.
          x
          p
          x

          # Transform single quotes.
          s/'/'\"'\"'/g

        b lllc

        :llld
        # A field header.
        # Print the previous line, held in the hold space, with a single quote
        # to end the assignment.
        x
        s/\$/'/
        p
        x

      b lllb

      :llle
      # EOF seen.
      # Print the previous line, held in the hold space, with a single quote
      # to end the assignment.
      x
      s/\$/'/
      p
      # Exit.
      n
      "
    if ! $sed_comments; then
      # Remove comments.
      sed_convert_to_cache_statements=`echo "$sed_convert_to_cache_statements" \
                                       | sed -e 's/^ *//' -e 's/^#.*//'`
    fi
  }

  if $have_associative; then
    # sed_convert_to_cache_statements does not depend on the module.
    modcachevar_assignment='modcache_\1[$1]='
    func_init_sed_convert_to_cache_statements
  fi

  # func_cache_lookup_module module
  #
  # looks up a module, like 'func_lookup_file modules/$module', and stores all
  # of its relevant data in a cache in the memory of the processing shell.  If
  # already cached, it does not look it up again, thus saving file access time.
  # Parameters:
  # - module                             non-empty string
  # Output if $have_associative:
  # - modcache_cached[$module]           set to yes
  # - modcache_description[$module] ==
  # - modcache_status[$module]        \  set to the field's value, minus the
  # - ...                             /  final newline,
  # - modcache_maintainer[$module]  ==   or unset if the field's value is empty
  # Output if ! $have_associative:
  # - cachevar                           a shell variable name
  # - ${cachevar}_cached                 set to $module
  # - ${cachevar}_description       ==
  # - ${cachevar}_status              \  set to the field's value, minus the
  # - ...                             /  final newline,
  # - ${cachevar}_maintainer        ==   or unset if the field's value is empty
  # - ${cachevar}_description_set   ==
  # - ${cachevar}_status_set          \  set to non-empty if the field's value
  # - ...                             /  is non-empty,
  # - ${cachevar}_maintainer_set    ==   or unset if the field's value is empty
  func_cache_lookup_module ()
  {
    if $have_associative; then
      eval 'cached=${modcache_cached[$1]}'
    else
      func_cache_var "$1"
      eval "cached=\"\$${cachevar}_cached\""
    fi
    if test -z "$cached"; then
      # Not found in cache. Look it up on the file system.
      func_lookup_file "modules/$1"
      if $have_associative; then
        eval 'modcache_cached[$1]=yes'
      else
        eval "${cachevar}_cached=\"\$1\""
      fi
      if ! $have_associative; then
        # sed_convert_to_cache_statements depends on the module.
        modcachevar_assignment="${cachevar}"'_\1_set=set; '"${cachevar}"'_\1='
        func_init_sed_convert_to_cache_statements
      fi
      cache_statements=`LC_ALL=C sed -n -e "$sed_convert_to_cache_statements" < "$lookedup_file"`
      eval "$cache_statements"
    else
      if ! $have_associative; then
        if test "$1" != "$cached"; then
          func_fatal_error "cache variable collision between $1 and $cached"
        fi
      fi
    fi
  }

fi

# func_get_description module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_description ()
{
  if ! $modcache; then
    func_lookup_file "modules/$1"
    sed -n -e "/^Description$sed_extract_prog" < "$lookedup_file"
  else
    func_cache_lookup_module "$1"
    # Output the field's value, including the final newline (if any).
    if $have_associative; then
      if eval 'test -n "${modcache_description[$1]+set}"'; then
        eval 'echo "${modcache_description[$1]}"'
      fi
    else
      eval "field_set=\"\$${cachevar}_description_set\""
      if test -n "$field_set"; then
        eval "field_value=\"\$${cachevar}_description\""
        echo "${field_value}"
      fi
    fi
  fi
}

# func_get_comment module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_comment ()
{
  if ! $modcache; then
    func_lookup_file "modules/$1"
    sed -n -e "/^Comment$sed_extract_prog" < "$lookedup_file"
  else
    func_cache_lookup_module "$1"
    # Output the field's value, including the final newline (if any).
    if $have_associative; then
      if eval 'test -n "${modcache_comment[$1]+set}"'; then
        eval 'echo "${modcache_comment[$1]}"'
      fi
    else
      eval "field_set=\"\$${cachevar}_comment_set\""
      if test -n "$field_set"; then
        eval "field_value=\"\$${cachevar}_comment\""
        echo "${field_value}"
      fi
    fi
  fi
}

# func_get_status module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_status ()
{
  if ! $modcache; then
    func_lookup_file "modules/$1"
    sed -n -e "/^Status$sed_extract_prog" < "$lookedup_file"
  else
    func_cache_lookup_module "$1"
    # Output the field's value, including the final newline (if any).
    if $have_associative; then
      if eval 'test -n "${modcache_status[$1]+set}"'; then
        eval 'echo "${modcache_status[$1]}"'
      fi
    else
      eval "field_set=\"\$${cachevar}_status_set\""
      if test -n "$field_set"; then
        eval "field_value=\"\$${cachevar}_status\""
        echo "${field_value}"
      fi
    fi
  fi
}

# func_get_notice module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_notice ()
{
  if ! $modcache; then
    func_lookup_file "modules/$1"
    sed -n -e "/^Notice$sed_extract_prog" < "$lookedup_file"
  else
    func_cache_lookup_module "$1"
    # Output the field's value, including the final newline (if any).
    if $have_associative; then
      if eval 'test -n "${modcache_notice[$1]+set}"'; then
        eval 'echo "${modcache_notice[$1]}"'
      fi
    else
      eval "field_set=\"\$${cachevar}_notice_set\""
      if test -n "$field_set"; then
        eval "field_value=\"\$${cachevar}_notice\""
        echo "${field_value}"
      fi
    fi
  fi
}

# func_get_applicability module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
# The expected result (on stdout) is either 'main', or 'tests', or 'all'.
func_get_applicability ()
{
  if ! $modcache; then
    func_lookup_file "modules/$1"
    my_applicability=`sed -n -e "/^Applicability$sed_extract_prog" < "$lookedup_file"`
  else
    func_cache_lookup_module "$1"
    # Get the field's value, without the final newline.
    if $have_associative; then
      eval 'my_applicability="${modcache_applicability[$1]}"'
    else
      eval "my_applicability=\"\$${cachevar}_applicability\""
    fi
  fi
  if test -n "$my_applicability"; then
    echo $my_applicability
  else
    # The default is 'main' or 'tests', depending on the module's name.
    case $1 in
      *-tests) echo "tests";;
      *)       echo "main";;
    esac
  fi
}

# func_get_filelist module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_filelist ()
{
  if ! $modcache; then
    func_lookup_file "modules/$1"
    sed -n -e "/^Files$sed_extract_prog" < "$lookedup_file"
  else
    func_cache_lookup_module "$1"
    # Output the field's value, including the final newline (if any).
    if $have_associative; then
      if eval 'test -n "${modcache_files[$1]+set}"'; then
        eval 'echo "${modcache_files[$1]}"'
      fi
    else
      eval "field_set=\"\$${cachevar}_files_set\""
      if test -n "$field_set"; then
        eval "field_value=\"\$${cachevar}_files\""
        echo "${field_value}"
      fi
    fi
  fi
  echo m4/00gnulib.m4
  echo m4/zzgnulib.m4
  echo m4/gnulib-common.m4
}

# func_filter_filelist outputvar separator filelist prefix suffix removed_prefix removed_suffix [added_prefix [added_suffix]]
# stores in outputvar the filtered and processed filelist. Filtering: Only the
# elements starting with prefix and ending with suffix are considered.
# Processing: removed_prefix and removed_suffix are removed from each element,
# added_prefix and added_suffix are added to each element.
# prefix, suffix should not contain shell-special characters.
# removed_prefix, removed_suffix should not contain the characters "$`\{}[]^|.
# added_prefix, added_suffix should not contain the characters \|&.
func_filter_filelist ()
{
  if test "$2" != "$nl" \
     || { $fast_func_append \
          && { test -z "$6" || $fast_func_remove_prefix; } \
          && { test -z "$7" || $fast_func_remove_suffix; }; \
        }; then
    ffflist=
    for fff in $3; do
      # Do not quote possibly-empty parameters in case patterns,
      # AIX and HP-UX ksh won't match them if they are empty.
      case "$fff" in
        $4*$5)
          if test -n "$6"; then
            func_remove_prefix fff "$6"
          fi
          if test -n "$7"; then
            func_remove_suffix fff "$7"
          fi
          fff="$8${fff}$9"
          if test -z "$ffflist"; then
            ffflist="${fff}"
          else
            func_append ffflist "$2${fff}"
          fi
          ;;
      esac
    done
  else
    sed_fff_filter="s|^$6\(.*\)$7\$|$8\\1$9|"
    ffflist=`for fff in $3; do
               case "$fff" in
                 $4*$5) echo "$fff" ;;
               esac
             done | sed -e "$sed_fff_filter"`
  fi
  eval "$1=\"\$ffflist\""
}

# func_get_dependencies module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_dependencies ()
{
  # ${module}-tests implicitly depends on ${module}, if that module exists.
  case "$1" in
    *-tests)
      fgd1="$1"
      func_remove_suffix fgd1 '-tests'
      if func_exists_module "$fgd1"; then
        echo "$fgd1"
      fi
      ;;
  esac
  # Then the explicit dependencies listed in the module description.
  { if ! $modcache; then
      func_lookup_file "modules/$1"
      sed -n -e "/^Depends-on$sed_extract_prog" < "$lookedup_file"
    else
      func_cache_lookup_module "$1"
      # Output the field's value, including the final newline (if any).
      if $have_associative; then
        if eval 'test -n "${modcache_dependson[$1]+set}"'; then
          eval 'echo "${modcache_dependson[$1]}"'
        fi
      else
        eval "field_set=\"\$${cachevar}_dependson_set\""
        if test -n "$field_set"; then
          eval "field_value=\"\$${cachevar}_dependson\""
          echo "${field_value}"
        fi
      fi
    fi
  } \
  | sed -e '/^#/d'
}

sed_dependencies_without_conditions='s/ *\[.*//'

# func_get_autoconf_early_snippet module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_autoconf_early_snippet ()
{
  if ! $modcache; then
    func_lookup_file "modules/$1"
    sed -n -e "/^configure\.ac-early$sed_extract_prog" < "$lookedup_file"
  else
    func_cache_lookup_module "$1"
    # Output the field's value, including the final newline (if any).
    if $have_associative; then
      if eval 'test -n "${modcache_configureac_early[$1]+set}"'; then
        eval 'echo "${modcache_configureac_early[$1]}"'
      fi
    else
      eval "field_set=\"\$${cachevar}_configureac_early_set\""
      if test -n "$field_set"; then
        eval "field_value=\"\$${cachevar}_configureac_early\""
        echo "${field_value}"
      fi
    fi
  fi
}

# func_get_autoconf_snippet module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_autoconf_snippet ()
{
  if ! $modcache; then
    func_lookup_file "modules/$1"
    sed -n -e "/^configure\.ac$sed_extract_prog" < "$lookedup_file"
  else
    func_cache_lookup_module "$1"
    # Output the field's value, including the final newline (if any).
    if $have_associative; then
      if eval 'test -n "${modcache_configureac[$1]+set}"'; then
        eval 'echo "${modcache_configureac[$1]}"'
      fi
    else
      eval "field_set=\"\$${cachevar}_configureac_set\""
      if test -n "$field_set"; then
        eval "field_value=\"\$${cachevar}_configureac\""
        echo "${field_value}"
      fi
    fi
  fi
}

# Concatenate lines with trailing slash.
# $1 is an optional filter to restrict the
# concatenation to groups starting with that expression
combine_lines() {
  sed -e "/$1.*"'\\$/{
    :a
    N
    s/\\\n/ /
    s/\\$/\\/
    ta
  }'
}

# func_get_automake_snippet_conditional module
# returns the part of the Makefile.am snippet that can be put inside Automake
# conditionals.
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_automake_snippet_conditional ()
{
  if ! $modcache; then
    func_lookup_file "modules/$1"
    sed -n -e "/^Makefile\.am$sed_extract_prog" < "$lookedup_file"
  else
    func_cache_lookup_module "$1"
    # Output the field's value, including the final newline (if any).
    if $have_associative; then
      if eval 'test -n "${modcache_makefile[$1]+set}"'; then
        eval 'echo "${modcache_makefile[$1]}"'
      fi
    else
      eval "field_set=\"\$${cachevar}_makefile_set\""
      if test -n "$field_set"; then
        eval "field_value=\"\$${cachevar}_makefile\""
        echo "${field_value}"
      fi
    fi
  fi
}

# func_get_automake_snippet_unconditional module
# returns the part of the Makefile.am snippet that must stay outside of
# Automake conditionals.
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_automake_snippet_unconditional ()
{
  case "$1" in
    *-tests)
      # *-tests module live in tests/, not lib/.
      # Synthesize an EXTRA_DIST augmentation.
      all_files=`func_get_filelist $1`
      func_filter_filelist tests_files " " "$all_files" 'tests/' '' 'tests/' ''
      extra_files="$tests_files"
      if test -n "$extra_files"; then
        echo "EXTRA_DIST +=" $extra_files
        echo
      fi
      ;;
    *)
      # Synthesize an EXTRA_DIST augmentation.
      sed_extract_mentioned_files='s/^lib_SOURCES[       ]*+=[   ]*//p'
      already_mentioned_files=` \
        { if ! $modcache; then
            func_lookup_file "modules/$1"
            sed -n -e "/^Makefile\.am$sed_extract_prog" < "$lookedup_file"
          else
            func_cache_lookup_module "$1"
            if $have_associative; then
              if eval 'test -n "${modcache_makefile[$1]+set}"'; then
                eval 'echo "${modcache_makefile[$1]}"'
              fi
            else
              eval 'field_set="$'"${cachevar}"'_makefile_set"'
              if test -n "$field_set"; then
                eval 'field_value="$'"${cachevar}"'_makefile"'
                echo "${field_value}"
              fi
            fi
          fi
        } \
        | combine_lines \
        | sed -n -e "$sed_extract_mentioned_files" | sed -e 's/#.*//'`
      all_files=`func_get_filelist $1`
      func_filter_filelist lib_files "$nl" "$all_files" 'lib/' '' 'lib/' ''
      # Remove $already_mentioned_files from $lib_files.
      echo "$lib_files" | LC_ALL=C sort -u > "$tmp"/lib-files
      extra_files=`for f in $already_mentioned_files; do echo $f; done \
                   | LC_ALL=C sort -u | LC_ALL=C join -v 2 - "$tmp"/lib-files`
      if test -n "$extra_files"; then
        echo "EXTRA_DIST +=" $extra_files
        echo
      fi
      # Synthesize also an EXTRA_lib_SOURCES augmentation.
      # This is necessary so that automake can generate the right list of
      # dependency rules.
      # A possible approach would be to use autom4te --trace of the redefined
      # AC_LIBOBJ and AC_REPLACE_FUNCS macros when creating the Makefile.am
      # (use autom4te --trace, not just grep, so that AC_LIBOBJ invocations
      # inside autoconf's built-in macros are not missed).
      # But it's simpler and more robust to do it here, based on the file list.
      # If some .c file exists and is not used with AC_LIBOBJ - for example,
      # a .c file is preprocessed into another .c file for BUILT_SOURCES -,
      # automake will generate a useless dependency; this is harmless.
      case "$1" in
        relocatable-prog-wrapper) ;;
        pt_chown) ;;
        *)
          func_filter_filelist extra_files "$nl" "$extra_files" '' '.c' '' ''
          if test -n "$extra_files"; then
            echo "EXTRA_lib_SOURCES +=" $extra_files
            echo
          fi
          ;;
      esac
      # Synthesize an EXTRA_DIST augmentation also for the files in build-aux/.
      func_filter_filelist buildaux_files "$nl" "$all_files" 'build-aux/' '' 'build-aux/' ''
      if test -n "$buildaux_files"; then
        sed_prepend_auxdir='s,^,$(top_srcdir)/'"$auxdir"'/,'
        echo "EXTRA_DIST += "`echo "$buildaux_files" | sed -e "$sed_prepend_auxdir"`
        echo
      fi
      ;;
  esac
}

# func_get_automake_snippet module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_automake_snippet ()
{
  func_get_automake_snippet_conditional "$1"
  func_get_automake_snippet_unconditional "$1"
}

# func_get_include_directive module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_include_directive ()
{
  {
    if ! $modcache; then
      func_lookup_file "modules/$1"
      sed -n -e "/^Include$sed_extract_prog" < "$lookedup_file"
    else
      func_cache_lookup_module "$1"
      # Output the field's value, including the final newline (if any).
      if $have_associative; then
        if eval 'test -n "${modcache_include[$1]+set}"'; then
          eval 'echo "${modcache_include[$1]}"'
        fi
      else
        eval "field_set=\"\$${cachevar}_include_set\""
        if test -n "$field_set"; then
          eval "field_value=\"\$${cachevar}_include\""
          echo "${field_value}"
        fi
      fi
    fi
  } | sed -e 's/^\(["<]\)/#include \1/'
}

# func_get_link_directive module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_link_directive ()
{
  if ! $modcache; then
    func_lookup_file "modules/$1"
    sed -n -e "/^Link$sed_extract_prog" < "$lookedup_file"
  else
    func_cache_lookup_module "$1"
    # Output the field's value, including the final newline (if any).
    if $have_associative; then
      if eval 'test -n "${modcache_link[$1]+set}"'; then
        eval 'echo "${modcache_link[$1]}"'
      fi
    else
      eval "field_set=\"\$${cachevar}_link_set\""
      if test -n "$field_set"; then
        eval "field_value=\"\$${cachevar}_link\""
        echo "${field_value}"
      fi
    fi
  fi
}

# func_get_license_raw module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_license_raw ()
{
  if ! $modcache; then
    func_lookup_file "modules/$1"
    sed -n -e "/^License$sed_extract_prog" < "$lookedup_file"
  else
    func_cache_lookup_module "$1"
    # Output the field's value, including the final newline (if any).
    if $have_associative; then
      if eval 'test -n "${modcache_license[$1]+set}"'; then
        eval 'echo "${modcache_license[$1]}"'
      fi
    else
      eval "field_set=\"\$${cachevar}_license_set\""
      if test -n "$field_set"; then
        eval "field_value=\"\$${cachevar}_license\""
        echo "${field_value}"
      fi
    fi
  fi
}

# func_get_license module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_license ()
{
  # Warn if the License field is missing.
  case "$1" in
    *-tests ) ;;
    * )
      license=`func_get_license_raw "$1"`
      if test -z "$license"; then
        func_warning "module $1 lacks a License"
      fi
      ;;
  esac
  case "$1" in
    parse-datetime )
      # These modules are under a weaker license only for the purpose of some
      # users who hand-edit it and don't use gnulib-tool. For the regular
      # gnulib users they are under a stricter license.
      echo "GPL"
      ;;
    * )
      {
        func_get_license_raw "$1"
        # The default is GPL.
        echo "GPL"
      } | sed -e 's,^ *$,,' | sed -e 1q
      ;;
  esac
}

# func_get_maintainer module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_maintainer ()
{
  if ! $modcache; then
    func_lookup_file "modules/$1"
    sed -n -e "/^Maintainer$sed_extract_prog" < "$lookedup_file"
  else
    func_cache_lookup_module "$1"
    # Output the field's value, including the final newline (if any).
    if $have_associative; then
      if eval 'test -n "${modcache_maintainer[$1]+set}"'; then
        eval 'echo "${modcache_maintainer[$1]}"'
      fi
    else
      eval "field_set=\"\$${cachevar}_maintainer_set\""
      if test -n "$field_set"; then
        eval "field_value=\"\$${cachevar}_maintainer\""
        echo "${field_value}"
      fi
    fi
  fi
}

# func_get_tests_module module
# Input:
# - local_gnulib_path  from --local-dir
func_get_tests_module ()
{
  # The naming convention for tests modules is hardwired: ${module}-tests.
  if test -f "$gnulib_dir/modules/$1"-tests \
     || func_path_foreach "$local_gnulib_path" func_exists_local_module %dir% "$1-tests"; then
    echo "$1"-tests
  fi
}

# func_get_dependencies_recursively module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_dependencies_recursively ()
{
  # In order to process every module only once (for speed), process an "input
  # list" of modules, producing an "output list" of modules. During each round,
  # more modules can be queued in the input list. Once a module on the input
  # list has been processed, it is added to the "handled list", so we can avoid
  # to process it again.
  handledmodules=
  inmodules="$1"
  outmodules=
  while test -n "$inmodules"; do
    inmodules_this_round="$inmodules"
    inmodules=                    # Accumulator, queue for next round
    for module in $inmodules_this_round; do
      func_verify_module
      if test -n "$module"; then
        func_append outmodules " $module"
        deps=`func_get_dependencies $module | sed -e "$sed_dependencies_without_conditions"`
        for dep in $deps; do
          func_append inmodules " $dep"
        done
      fi
    done
    handledmodules=`for m in $handledmodules $inmodules_this_round; do echo $m; done | LC_ALL=C sort -u`
    # Remove $handledmodules from $inmodules.
    for m in $inmodules; do echo $m; done | LC_ALL=C sort -u > "$tmp"/queued-modules
    inmodules=`echo "$handledmodules" | LC_ALL=C join -v 2 - "$tmp"/queued-modules`
  done
  rm -f "$tmp"/queued-modules
  for m in $outmodules; do echo $m; done | LC_ALL=C sort -u
}

# func_get_link_directive_recursively module
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
func_get_link_directive_recursively ()
{
  # In order to process every module only once (for speed), process an "input
  # list" of modules, producing an "output list" of modules. During each round,
  # more modules can be queued in the input list. Once a module on the input
  # list has been processed, it is added to the "handled list", so we can avoid
  # to process it again.
  handledmodules=
  inmodules="$1"
  outmodules=
  while test -n "$inmodules"; do
    inmodules_this_round="$inmodules"
    inmodules=                    # Accumulator, queue for next round
    for module in $inmodules_this_round; do
      func_verify_module
      if test -n "$module"; then
        if grep '^Link:[        ]*$' "$lookedup_file" >/dev/null; then
          # The module description has a 'Link:' field. Ignore the dependencies.
          func_append outmodules " $module"
        else
          # The module description has no 'Link:' field. Recurse through the dependencies.
          deps=`func_get_dependencies $module | sed -e "$sed_dependencies_without_conditions"`
          for dep in $deps; do
            func_append inmodules " $dep"
          done
        fi
      fi
    done
    handledmodules=`for m in $handledmodules $inmodules_this_round; do echo $m; done | LC_ALL=C sort -u`
    # Remove $handledmodules from $inmodules.
    for m in $inmodules; do echo $m; done | LC_ALL=C sort -u > "$tmp"/queued-modules
    inmodules=`echo "$handledmodules" | LC_ALL=C join -v 2 - "$tmp"/queued-modules`
  done
  rm -f "$tmp"/queued-modules
  for m in $outmodules; do func_get_link_directive "$m"; done | LC_ALL=C sort -u | sed -e '/^$/d'
}

# func_acceptable module
# tests whether a module is acceptable.
# Input:
# - avoidlist       list of modules to avoid
func_acceptable ()
{
  for avoid in $avoidlist; do
    if test "$avoid" = "$1"; then
      return 1
    fi
  done
  return 0
}

# sed expression to keep the first 32 characters of each line.
sed_first_32_chars='s/^\(................................\).*/\1/'

# func_module_shellfunc_name module
# computes the shell function name that will contain the m4 macros for the module.
# Input:
# - macro_prefix    prefix to use
# Output:
# - shellfunc       shell function name
func_module_shellfunc_name ()
{
  case $1 in
    *[!a-zA-Z0-9_]*)
      shellfunc=func_${macro_prefix}_gnulib_m4code_`echo "$1" | md5sum | LC_ALL=C sed -e "$sed_first_32_chars"` ;;
    *)
      shellfunc=func_${macro_prefix}_gnulib_m4code_$1 ;;
  esac
}

# func_module_shellvar_name module
# computes the shell variable name the will be set to true once the m4 macros
# for the module have been executed.
# Output:
# - shellvar        shell variable name
func_module_shellvar_name ()
{
  case $1 in
    *[!a-zA-Z0-9_]*)
      shellvar=${macro_prefix}_gnulib_enabled_`echo "$1" | md5sum | LC_ALL=C sed -e "$sed_first_32_chars"` ;;
    *)
      shellvar=${macro_prefix}_gnulib_enabled_$1 ;;
  esac
}

# func_module_conditional_name module
# computes the automake conditional name for the module.
# Output:
# - conditional     name of automake conditional
func_module_conditional_name ()
{
  case $1 in
    *[!a-zA-Z0-9_]*)
      conditional=${macro_prefix}_GNULIB_ENABLED_`echo "$1" | md5sum | LC_ALL=C sed -e "$sed_first_32_chars"` ;;
    *)
      conditional=${macro_prefix}_GNULIB_ENABLED_$1 ;;
  esac
}

# func_uncond_add_module B
# notes the presence of B as an unconditional module.
#
# func_conddep_add_module A B cond
# notes the presence of a conditional dependency from module A to module B,
# subject to the condition that A is enabled and cond is true.
#
# func_cond_module_p B
# tests whether module B is conditional.
#
# func_cond_module_condition A B
# returns the condition when B should be enabled as a dependency of A, once the
# m4 code for A has been executed.
# Output: - condition
#
if $have_associative; then
  declare -A conddep_isuncond
  declare -A conddep_dependers
  declare -A conddep_condition
  func_uncond_add_module ()
  {
    eval 'conddep_isuncond[$1]=true'
    eval 'unset conddep_dependers[$1]'
  }
  func_conddep_add_module ()
  {
    eval 'isuncond="${conddep_isuncond[$2]}"'
    if test -z "$isuncond"; then
      # No unconditional dependency to B known at this point.
      eval 'conddep_dependers[$2]="${conddep_dependers[$2]} $1"'
      eval 'conddep_condition[$1---$2]="$3"'
    fi
  }
  func_cond_module_p ()
  {
    eval 'previous_dependers="${conddep_dependers[$1]}"'
    test -n "$previous_dependers"
  }
  func_cond_module_condition ()
  {
    eval 'condition="${conddep_condition[$1---$2]}"'
  }
else
  func_uncond_add_module ()
  {
    case $1 in
      *[!a-zA-Z0-9_]*)
        suffix=`echo "$1" | md5sum | LC_ALL=C sed -e "$sed_first_32_chars"` ;;
      *)
        suffix=$1 ;;
    esac
    eval 'conddep_isuncond_'"$suffix"'=true'
    eval 'unset conddep_dependers_'"$suffix"
  }
  func_conddep_add_module ()
  {
    case $2 in
      *[!a-zA-Z0-9_]*)
        suffix=`echo "$2" | md5sum | LC_ALL=C sed -e "$sed_first_32_chars"` ;;
      *)
        suffix=$2 ;;
    esac
    eval 'isuncond="${conddep_isuncond_'"$suffix"'}"'
    if test -z "$isuncond"; then
      eval 'conddep_dependers_'"$suffix"'="${conddep_dependers_'"$suffix"'} $1"'
      suffix=`echo "$1---$2" | md5sum | LC_ALL=C sed -e "$sed_first_32_chars"`
      eval 'conddep_condition_'"$suffix"'="$3"'
    fi
  }
  func_cond_module_p ()
  {
    case $1 in
      *[!a-zA-Z0-9_]*)
        suffix=`echo "$1" | md5sum | LC_ALL=C sed -e "$sed_first_32_chars"` ;;
      *)
        suffix=$1 ;;
    esac
    eval 'previous_dependers="${conddep_dependers_'"$suffix"'}"'
    test -n "$previous_dependers"
  }
  func_cond_module_condition ()
  {
    suffix=`echo "$1---$2" | md5sum | LC_ALL=C sed -e "$sed_first_32_chars"`
    eval 'condition="${conddep_condition_'"$suffix"'}"'
  }
fi

# func_modules_transitive_closure
# Input:
# - local_gnulib_path  from --local-dir
# - gnu_make        true if --gnu-make was given, false otherwise
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - modules         list of specified modules
# - inctests        true if tests should be included, false otherwise
# - incobsolete     true if obsolete modules among dependencies should be
#                   included, blank otherwise
# - inc_cxx_tests   true if C++ interoperability tests should be included,
#                   blank otherwise
# - inc_longrunning_tests  true if long-runnings tests should be included,
#                          blank otherwise
# - inc_privileged_tests  true if tests that require root privileges should be
#                         included, blank otherwise
# - inc_unportable_tests  true if tests that fail on some platforms should be
#                         included, blank otherwise
# - inc_all_direct_tests   true if all kinds of problematic unit tests among
#                          the unit tests of the specified modules should be
#                          included, blank otherwise
# - inc_all_indirect_tests   true if all kinds of problematic unit tests among
#                            the unit tests of the dependencies should be
#                            included, blank otherwise
# - excl_cxx_tests   true if C++ interoperability tests should be excluded,
#                    blank otherwise
# - excl_longrunning_tests  true if long-runnings tests should be excluded,
#                           blank otherwise
# - excl_privileged_tests  true if tests that require root privileges should be
#                          excluded, blank otherwise
# - excl_unportable_tests  true if tests that fail on some platforms should be
#                          excluded, blank otherwise
# - avoidlist       list of modules to avoid
# - cond_dependencies  true if conditional dependencies shall be supported,
#                      blank otherwise
# - tmp             pathname of a temporary directory
# Output:
# - modules         list of modules, including dependencies
# - conddep_dependers, conddep_condition  information about conditionally
#                                         enabled modules
func_modules_transitive_closure ()
{
  sed_escape_dependency='s|\([/.]\)|\\\1|g'
  # In order to process every module only once (for speed), process an "input
  # list" of modules, producing an "output list" of modules. During each round,
  # more modules can be queued in the input list. Once a module on the input
  # list has been processed, it is added to the "handled list", so we can avoid
  # to process it again.
  handledmodules=
  inmodules="$modules"
  outmodules=
  fmtc_inc_all_tests="$inc_all_direct_tests"
  if test "$cond_dependencies" = true; then
    for module in $inmodules; do
      func_verify_module
      if test -n "$module"; then
        if func_acceptable $module; then
          func_uncond_add_module $module
        fi
      fi
    done
  fi
  while test -n "$inmodules"; do
    inmodules_this_round="$inmodules"
    inmodules=                    # Accumulator, queue for next round
    for module in $inmodules_this_round; do
      func_verify_module
      if test -n "$module"; then
        if func_acceptable $module; then
          func_append outmodules " $module"
          if test "$cond_dependencies" = true; then
            if ! $gnu_make \
               && func_get_automake_snippet_conditional $module \
                  | grep '^if ' > /dev/null; then
              # A module whose Makefile.am snippet contains a reference to an
              # automake conditional. If we were to use it conditionally, we
              # would get an error
              #   configure: error: conditional "..." was never defined.
              # because automake 1.11.1 does not handle nested conditionals
              # correctly. As a workaround, make the module unconditional.
              func_uncond_add_module $module
            fi
            if func_cond_module_p $module; then
              conditional=true
            else
              conditional=false
            fi
          fi
          deps=`func_get_dependencies $module | sed -e "$sed_dependencies_without_conditions"`
          # Duplicate dependencies are harmless, but Jim wants a warning.
          duplicated_deps=`echo "$deps" | LC_ALL=C sort | LC_ALL=C uniq -d`
          if test -n "$duplicated_deps"; then
            func_warning "module $module has duplicated dependencies: "`echo $duplicated_deps`
          fi
          if $inctests; then
            testsmodule=`func_get_tests_module $module`
            if test -n "$testsmodule"; then
              deps="$deps $testsmodule"
            fi
          fi
          for dep in $deps; do
            # Determine whether to include the dependency or tests module.
            inc=true
            for word in `func_get_status $dep`; do
              case "$word" in
                obsolete)
                  test -n "$incobsolete" \
                    || inc=false
                  ;;
                c++-test)
                  test -z "$excl_cxx_tests" \
                    || inc=false
                  test -n "$fmtc_inc_all_tests" || test -n "$inc_cxx_tests" \
                    || inc=false
                  ;;
                longrunning-test)
                  test -z "$excl_longrunning_tests" \
                    || inc=false
                  test -n "$fmtc_inc_all_tests" || test -n "$inc_longrunning_tests" \
                    || inc=false
                  ;;
                privileged-test)
                  test -z "$excl_privileged_tests" \
                    || inc=false
                  test -n "$fmtc_inc_all_tests" || test -n "$inc_privileged_tests" \
                    || inc=false
                  ;;
                unportable-test)
                  test -z "$excl_unportable_tests" \
                    || inc=false
                  test -n "$fmtc_inc_all_tests" || test -n "$inc_unportable_tests" \
                    || inc=false
                  ;;
                *-test)
                  test -n "$fmtc_inc_all_tests" \
                    || inc=false
                  ;;
              esac
            done
            if $inc && func_acceptable "$dep"; then
              func_append inmodules " $dep"
              if test "$cond_dependencies" = true; then
                escaped_dep=`echo "$dep" | sed -e "$sed_escape_dependency"`
                sed_extract_condition1='/^ *'"$escaped_dep"' *$/{
                  s/^.*$/true/p
                }'
                sed_extract_condition2='/^ *'"$escaped_dep"' *\[.*\] *$/{
                  s/^ *'"$escaped_dep"' *\[\(.*\)\] *$/\1/p
                }'
                condition=`func_get_dependencies $module | sed -n -e "$sed_extract_condition1" -e "$sed_extract_condition2"`
                if test "$condition" = true; then
                  condition=
                fi
                if test -n "$condition"; then
                  func_conddep_add_module "$module" "$dep" "$condition"
                else
                  if $conditional; then
                    func_conddep_add_module "$module" "$dep" true
                  else
                    func_uncond_add_module "$dep"
                  fi
                fi
              fi
            fi
          done
        fi
      fi
    done
    handledmodules=`for m in $handledmodules $inmodules_this_round; do echo $m; done | LC_ALL=C sort -u`
    # Remove $handledmodules from $inmodules.
    for m in $inmodules; do echo $m; done | LC_ALL=C sort -u > "$tmp"/queued-modules
    inmodules=`echo "$handledmodules" | LC_ALL=C join -v 2 - "$tmp"/queued-modules`
    fmtc_inc_all_tests="$inc_all_indirect_tests"
  done
  modules=`for m in $outmodules; do echo $m; done | LC_ALL=C sort -u`
  rm -f "$tmp"/queued-modules
}

# func_show_module_list
# Input:
# - specified_modules  list of specified modules (one per line, sorted)
# - modules         complete list of modules (one per line, sorted)
# - tmp             pathname of a temporary directory
func_show_module_list ()
{
  if case "$TERM" in
       xterm*) test -t 1;;
       *) false;;
     esac; then
    # Assume xterm compatible escape sequences.
    bold_on=`printf '\033[1m'`
    bold_off=`printf '\033[0m'`
  else
    bold_on=
    bold_off=
  fi
  echo "Module list with included dependencies (indented):"
  echo "$specified_modules" | sed -e '/^$/d' -e 's/$/| /' > "$tmp"/specified-modules
  echo "$modules" | sed -e '/^$/d' \
    | LC_ALL=C join -t '|' -a2 "$tmp"/specified-modules - \
    | sed -e 's/^\(.*\)|.*/|\1/' -e 's/^/    /' -e 's/^    |\(.*\)$/  '"${bold_on}"'\1'"${bold_off}"'/'
}

# func_modules_transitive_closure_separately
# Determine main module list and tests-related module list separately.
# The main module list is the transitive closure of the specified modules,
# ignoring tests modules. Its lib/* sources go into $sourcebase/. If --lgpl
# is specified, it will consist only of LGPLed source.
# The tests-related module list is the transitive closure of the specified
# modules, including tests modules, minus the main module list excluding
# modules of applicability 'all'. Its lib/* sources (brought in through
# dependencies of *-tests modules) go into $testsbase/. It may contain GPLed
# source, even if --lgpl is specified.
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - specified_modules  list of specified modules
# - inctests        true if tests should be included, false otherwise
# - incobsolete     true if obsolete modules among dependencies should be
#                   included, blank otherwise
# - inc_cxx_tests   true if C++ interoperability tests should be included,
#                   blank otherwise
# - inc_longrunning_tests  true if long-runnings tests should be included,
#                          blank otherwise
# - inc_privileged_tests  true if tests that require root privileges should be
#                         included, blank otherwise
# - inc_unportable_tests  true if tests that fail on some platforms should be
#                         included, blank otherwise
# - inc_all_direct_tests   true if all kinds of problematic unit tests among
#                          the unit tests of the specified modules should be
#                          included, blank otherwise
# - inc_all_indirect_tests   true if all kinds of problematic unit tests among
#                            the unit tests of the dependencies should be
#                            included, blank otherwise
# - excl_cxx_tests   true if C++ interoperability tests should be excluded,
#                    blank otherwise
# - excl_longrunning_tests  true if long-runnings tests should be excluded,
#                           blank otherwise
# - excl_privileged_tests  true if tests that require root privileges should be
#                          excluded, blank otherwise
# - excl_unportable_tests  true if tests that fail on some platforms should be
#                          excluded, blank otherwise
# - avoidlist       list of modules to avoid
# - cond_dependencies  true if conditional dependencies shall be supported,
#                      blank otherwise
# - tmp             pathname of a temporary directory
# Output:
# - main_modules    list of modules, including dependencies
# - testsrelated_modules  list of tests-related modules, including dependencies
# - conddep_dependers, conddep_condition  information about conditionally
#                                         enabled modules
func_modules_transitive_closure_separately ()
{
  # Determine main module list.
  saved_inctests="$inctests"
  inctests=false
  modules="$specified_modules"
  func_modules_transitive_closure
  main_modules="$modules"
  inctests="$saved_inctests"
  if test $verbose -ge 1; then
    echo "Main module list:"
    echo "$main_modules" | sed -e 's/^/  /'
  fi
  # Determine tests-related module list.
  echo "$final_modules" | LC_ALL=C sort -u > "$tmp"/final-modules
  testsrelated_modules=`for module in $main_modules; do
                          if test \`func_get_applicability $module\` = main; then
                            echo $module
                          fi
                        done \
                        | LC_ALL=C sort -u | LC_ALL=C join -v 2 - "$tmp"/final-modules`
  # If testsrelated_modules consists only of modules with applicability 'all',
  # set it to empty (because such modules are only helper modules for other modules).
  have_nontrivial_testsrelated_modules=
  for module in $testsrelated_modules; do
    if test `func_get_applicability $module` != all; then
      have_nontrivial_testsrelated_modules=yes
      break
    fi
  done
  if test -z "$have_nontrivial_testsrelated_modules"; then
    testsrelated_modules=
  fi
  if test $verbose -ge 1; then
    echo "Tests-related module list:"
    echo "$testsrelated_modules" | sed -e 's/^/  /'
  fi
}

# func_determine_use_libtests
# Determines whether a $testsbase/libtests.a is needed.
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - testsrelated_modules  list of tests-related modules, including dependencies
# Output:
# - use_libtests    true if a $testsbase/libtests.a is needed, false otherwise
func_determine_use_libtests ()
{
  use_libtests=false
  for module in $testsrelated_modules; do
    func_verify_nontests_module
    if test -n "$module"; then
      all_files=`func_get_filelist $module`
      # Test whether some file in $all_files lies in lib/.
      for f in $all_files; do
        case $f in
          lib/*)
            use_libtests=true
            break 2
            ;;
        esac
      done
    fi
  done
}

# func_remove_if_blocks
# removes if...endif blocks from an automake snippet.
func_remove_if_blocks ()
{
  sed -n -e '/^if / {
    :a
      n
      s/^endif//
      tb
      ba
    :b
  }
  p'
}

# func_modules_add_dummy
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - modules         list of modules, including dependencies
# Output:
# - modules         list of modules, including 'dummy' if needed
func_modules_add_dummy ()
{
  # Determine whether any module provides a lib_SOURCES augmentation.
  have_lib_SOURCES=
  for module in $modules; do
    func_verify_nontests_module
    if test -n "$module"; then
      if test "$cond_dependencies" = true && func_cond_module_p $module; then
        # Ignore conditional modules, since they are not guaranteed to
        # contribute to lib_SOURCES.
        :
      else
        # Extract the value of unconditional "lib_SOURCES += ..." augmentations.
        for file in `func_get_automake_snippet "$module" | combine_lines |
                     func_remove_if_blocks |
                     sed -n -e 's,^lib_SOURCES[  ]*+=\([^#]*\).*$,\1,p'`; do
          # Ignore .h files since they are not compiled.
          case "$file" in
            *.h) ;;
            *)
              have_lib_SOURCES=yes
              break 2
              ;;
          esac
        done
      fi
    fi
  done
  # Add the dummy module, to make sure the library will be non-empty.
  if test -z "$have_lib_SOURCES"; then
    if func_acceptable "dummy"; then
      func_append modules " dummy"
    fi
  fi
}

# func_modules_add_dummy_separately
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - main_modules    list of modules, including dependencies
# - testsrelated_modules  list of tests-related modules, including dependencies
# - use_libtests    true if a $testsbase/libtests.a is needed, false otherwise
# Output:
# - main_modules    list of modules, including 'dummy' if needed
# - testsrelated_modules  list of tests-related modules, including 'dummy' if
#                         needed
func_modules_add_dummy_separately ()
{
  # Add the dummy module to the main module list if needed.
  modules="$main_modules"
  func_modules_add_dummy
  main_modules="$modules"

  # Add the dummy module to the tests-related module list if needed.
  if $use_libtests; then
    modules="$testsrelated_modules"
    func_modules_add_dummy
    testsrelated_modules="$modules"
  fi
}

# func_modules_notice
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - verbose         integer, default 0, inc/decremented by --verbose/--quiet
# - modules         list of modules, including dependencies
func_modules_notice ()
{
  if test $verbose -ge -1; then
    for module in $modules; do
      func_verify_module
      if test -n "$module"; then
        msg=`func_get_notice $module`
        if test -n "$msg"; then
          echo "Notice from module $module:"
          echo "$msg" | sed -e 's/^/  /'
        fi
      fi
    done
  fi
}

# func_modules_to_filelist
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - modules         list of modules, including dependencies
# Output:
# - files           list of files
func_modules_to_filelist ()
{
  files=
  for module in $modules; do
    func_verify_module
    if test -n "$module"; then
      fs=`func_get_filelist $module`
      func_append files " $fs"
    fi
  done
  files=`for f in $files; do echo $f; done | LC_ALL=C sort -u`
}

# func_modules_to_filelist_separately
# Determine the final file lists.
# They must be computed separately, because files in lib/* go into
# $sourcebase/ if they are in the main file list but into $testsbase/
# if they are in the tests-related file list. Furthermore lib/dummy.c
# can be in both.
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - main_modules    list of modules, including dependencies
# - testsrelated_modules  list of tests-related modules, including dependencies
func_modules_to_filelist_separately ()
{
  # Determine final main file list.
  modules="$main_modules"
  func_modules_to_filelist
  main_files="$files"
  # Determine final tests-related file list.
  modules="$testsrelated_modules"
  func_modules_to_filelist
  testsrelated_files=`echo "$files" | sed -e 's,^lib/,tests=lib/,'`
  # Merge both file lists.
  sed_remove_empty_lines='/^$/d'
  files=`{ echo "$main_files"; echo "$testsrelated_files"; } | sed -e "$sed_remove_empty_lines" | LC_ALL=C sort -u`
  if test $verbose -ge 0; then
    echo "File list:"
    sed_prettyprint_files='s,^tests=lib/\(.*\)$,lib/\1 -> tests/\1,'
    echo "$files" | sed -e "$sed_prettyprint_files" -e 's/^/  /'
  fi
}

# func_compute_include_guard_prefix
# Determine include_guard_prefix.
# Input:
# - macro_prefix    prefix of gl_LIBOBJS macros to use
# Output:
# - include_guard_prefix  replacement for ${gl_include_guard_prefix}
# - sed_replace_include_guard_prefix
#                   sed expression for resolving ${gl_include_guard_prefix}
func_compute_include_guard_prefix ()
{
  if test "$macro_prefix" = gl; then
    include_guard_prefix='GL'
  else
    include_guard_prefix='GL_'`echo "$macro_prefix" | LC_ALL=C tr '[a-z]' '[A-Z]'`
  fi
  sed_replace_include_guard_prefix='s/\${gl_include_guard_prefix}/'"${include_guard_prefix}"'/g'
}

# func_execute_command command [args...]
# Executes a command.
# Uses also the variables
# - verbose         integer, default 0, inc/decremented by --verbose/--quiet
func_execute_command ()
{
  if test $verbose -ge 0; then
    echo "executing $*"
    "$@"
  else
    # Commands like automake produce output to stderr even when they succeed.
    # Turn this output off if the command succeeds.
    "$@" > "$tmp"/cmdout 2>&1
    cmdret=$?
    if test $cmdret = 0; then
      rm -f "$tmp"/cmdout
    else
      echo "executing $*"
      cat "$tmp"/cmdout 1>&2
      rm -f "$tmp"/cmdout
      (exit $cmdret)
    fi
  fi
}

# func_dest_tmpfilename file
# determines the name of a temporary file (file is relative to destdir).
# Input:
# - destdir         target directory
# - doit            : if actions shall be executed, false if only to be printed
# - tmp             pathname of a temporary directory
# Sets variable:
#   - tmpfile       absolute filename of the temporary file
func_dest_tmpfilename ()
{
  if $doit; then
    # Put the new contents of $file in a file in the same directory (needed
    # to guarantee that an 'mv' to "$destdir/$file" works).
    tmpfile="$destdir/$1.tmp"
  else
    # Put the new contents of $file in a file in a temporary directory
    # (because the directory of "$file" might not exist).
    tmpfile="$tmp"/`basename "$1"`.tmp
  fi
}

# func_is_local_file lookedup_file file
# check whether file should be instantiated from local gnulib directory
func_is_local_file ()
{
  dname=$1
  func_remove_suffix dname "/$2"
  func_path_foreach "$local_gnulib_path" test %dir% = "$dname"
}

# func_should_link
# determines whether the file $f should be copied, symlinked, or hardlinked.
# Input:
# - copymode        copy mode for files in general
# - lcopymode       copy mode for files from local_gnulib_path
# - f               the original file name
# - lookedup_file   name of the merged (combined) file
# Sets variable:
# - copyaction      copy or symlink or hardlink
func_should_link ()
{
  if test -n "$lcopymode" && func_is_local_file "$lookedup_file" "$f"; then
    copyaction="$lcopymode"
  else
    if test -n "$copymode"; then
      copyaction="$copymode"
    else
      copyaction=copy
    fi
  fi
}

# func_add_file
# copies a file from gnulib into the destination directory. The destination
# is known to not exist.
# Input:
# - destdir         target directory
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - f               the original file name
# - lookedup_file   name of the merged (combined) file
# - lookedup_tmp    true if it is located in the tmp directory, blank otherwise
# - g               the rewritten file name
# - tmpfile         absolute filename of the temporary file
# - doit            : if actions shall be executed, false if only to be printed
# - copymode        copy mode for files in general
# - lcopymode       copy mode for files from local_gnulib_path
func_add_file ()
{
  if $doit; then
    echo "Copying file $g"
    func_should_link
    if test "$copyaction" = symlink \
       && test -z "$lookedup_tmp" \
       && cmp -s "$lookedup_file" "$tmpfile"; then
      func_symlink_if_changed "$lookedup_file" "$destdir/$g"
    else
      if test "$copyaction" = hardlink \
         && test -z "$lookedup_tmp" \
         && cmp -s "$lookedup_file" "$tmpfile"; then
        func_hardlink "$lookedup_file" "$destdir/$g"
      else
        mv -f "$tmpfile" "$destdir/${g}" || func_fatal_error "failed"
      fi
    fi
  else
    echo "Copy file $g"
  fi
}

# func_update_file
# copies a file from gnulib into the destination directory. The destination
# is known to exist.
# Input:
# - destdir         target directory
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - f               the original file name
# - lookedup_file   name of the merged (combined) file
# - lookedup_tmp    true if it is located in the tmp directory, blank otherwise
# - g               the rewritten file name
# - tmpfile         absolute filename of the temporary file
# - doit            : if actions shall be executed, false if only to be printed
# - copymode        copy mode for files in general
# - lcopymode       copy mode for files from local_gnulib_path
# - already_present  nonempty if the file should already exist, empty otherwise
func_update_file ()
{
  if cmp -s "$destdir/$g" "$tmpfile"; then
    : # The file has not changed.
  else
    # Replace the file.
    if $doit; then
      if test -n "$already_present"; then
        echo "Updating file $g (backup in ${g}~)"
      else
        echo "Replacing file $g (non-gnulib code backed up in ${g}~) !!"
      fi
      mv -f "$destdir/$g" "$destdir/${g}~" || func_fatal_error "failed"
      func_should_link
      if test "$copyaction" = symlink \
         && test -z "$lookedup_tmp" \
         && cmp -s "$lookedup_file" "$tmpfile"; then
        func_symlink_if_changed "$lookedup_file" "$destdir/$g"
      else
        if test "$copyaction" = hardlink \
           && test -z "$lookedup_tmp" \
           && cmp -s "$lookedup_file" "$tmpfile"; then
          func_hardlink "$lookedup_file" "$destdir/$g"
        else
          mv -f "$tmpfile" "$destdir/${g}" || func_fatal_error "failed"
        fi
      fi
    else
      if test -n "$already_present"; then
        echo "Update file $g (backup in ${g}~)"
      else
        echo "Replace file $g (non-gnulib code backed up in ${g}~) !!"
      fi
    fi
  fi
}

# func_emit_lib_Makefile_am
# emits the contents of library makefile to standard output.
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - modules         list of modules, including dependencies
# - libname         library name
# - pobase          directory relative to destdir where to place *.po files
# - auxdir          directory relative to destdir where to place build aux files
# - gnu_make        true if --gnu-make was given, false otherwise
# - makefile_name   from --makefile-name
# - libtool         true if libtool will be used, false or blank otherwise
# - macro_prefix    prefix of gl_LIBOBJS macros to use
# - po_domain       prefix of i18n domain to use (without -gnulib suffix)
# - witness_c_macro  from --witness-c-macro
# - actioncmd       (optional) command that will reproduce this invocation
# - for_test        true if creating a package for testing, false otherwise
# - sed_replace_include_guard_prefix
#                   sed expression for resolving ${gl_include_guard_prefix}
# - destfile        filename relative to destdir of makefile being generated
# Input/Output:
# - makefile_am_edits and makefile_am_edit${edit}_{dir,var,val,dotfirst}
#                   list of edits to be done to Makefile.am variables
# Output:
# - uses_subdirs    nonempty if object files in subdirs exist
func_emit_lib_Makefile_am ()
{
  # When using GNU make, or when creating an includable Makefile.am snippet,
  # augment variables with += instead of assigning them.
  if $gnu_make || test -n "$makefile_name"; then
    assign='+='
  else
    assign='='
  fi
  if test "$libtool" = true; then
    libext=la
    perhapsLT=LT
    sed_eliminate_LDFLAGS="$sed_noop"
  else
    libext=a
    perhapsLT=
    sed_eliminate_LDFLAGS='/^lib_LDFLAGS[        ]*+=/d'
  fi
  if $for_test; then
    # When creating a package for testing: Attempt to provoke failures,
    # especially link errors, already during "make" rather than during
    # "make check", because "make check" is not possible in a cross-compiling
    # situation. Turn check_PROGRAMS into noinst_PROGRAMS.
    sed_transform_check_PROGRAMS='s,check_PROGRAMS,noinst_PROGRAMS,g'
  else
    sed_transform_check_PROGRAMS="$sed_noop"
  fi
  echo "## DO NOT EDIT! GENERATED AUTOMATICALLY!"
  $gnu_make ||
      echo "## Process this file with automake to produce Makefile.in."
  func_emit_copyright_notice
  if test -n "$actioncmd"; then
    printf '# Reproduce by:\n%s\n' "$actioncmd"
  fi
  echo
  uses_subdirs=
  {
    for module in $modules; do
      func_verify_nontests_module
      if test -n "$module"; then
        {
          func_get_automake_snippet_conditional "$module" |
            LC_ALL=C \
            sed -e 's,lib_LIBRARIES,lib%_LIBRARIES,g' \
                -e 's,lib_LTLIBRARIES,lib%_LTLIBRARIES,g' \
                -e "$sed_eliminate_LDFLAGS" \
                -e 's,lib_\([A-Z][A-Z]*\),'"${libname}_${libext}"'_\1,g' \
                -e 's,lib%_LIBRARIES,lib_LIBRARIES,g' \
                -e 's,lib%_LTLIBRARIES,lib_LTLIBRARIES,g' \
                -e "$sed_transform_check_PROGRAMS" \
                -e "$sed_replace_include_guard_prefix"
          if test "$module" = 'alloca'; then
            echo "${libname}_${libext}_LIBADD += @${perhapsLT}ALLOCA@"
            echo "${libname}_${libext}_DEPENDENCIES += @${perhapsLT}ALLOCA@"
          fi
        } | combine_lines "${libname}_${libext}_SOURCES" > "$tmp"/amsnippet1
        {
          func_get_automake_snippet_unconditional "$module" |
            LC_ALL=C sed -e 's,lib_\([A-Z][A-Z]*\),'"${libname}_${libext}"'_\1,g'
        } > "$tmp"/amsnippet2
        # Skip the contents if it's entirely empty.
        if grep '[^      ]' "$tmp"/amsnippet1 "$tmp"/amsnippet2 > /dev/null ; then
          echo "## begin gnulib module $module"
          if $gnu_make; then
            echo "ifeq (,\$(OMIT_GNULIB_MODULE_$module))"
            convert_to_gnu_make='s/^if \(.*\)/ifneq (,$(\1))/'
          else
            convert_to_gnu_make=
          fi
          echo
          if test "$cond_dependencies" = true; then
            if func_cond_module_p "$module"; then
              func_module_conditional_name "$module"
              if $gnu_make; then
                echo "ifneq (,\$($conditional))"
              else
                echo "if $conditional"
              fi
            fi
          fi
          sed "$convert_to_gnu_make" "$tmp"/amsnippet1
          if test "$cond_dependencies" = true; then
            if func_cond_module_p "$module"; then
              echo "endif"
            fi
          fi
          sed "$convert_to_gnu_make" "$tmp"/amsnippet2
          if $gnu_make; then
            echo "endif"
          fi
          echo "## end   gnulib module $module"
          echo
        fi
        rm -f "$tmp"/amsnippet1 "$tmp"/amsnippet2
        # Test whether there are some source files in subdirectories.
        for f in `func_get_filelist "$module"`; do
          case $f in
            lib/*/*.c)
              uses_subdirs=yes
              break
              ;;
          esac
        done
      fi
    done
  } > "$tmp"/allsnippets
  if test -z "$makefile_name"; then
    # If there are source files in subdirectories, prevent collision of the
    # object files (example: hash.c and libxml/hash.c).
    subdir_options=
    if test -n "$uses_subdirs"; then
      subdir_options=' subdir-objects'
    fi
    echo "AUTOMAKE_OPTIONS = 1.11 gnits${subdir_options}"
  fi
  echo
  if test -z "$makefile_name"; then
    echo "SUBDIRS ="
    echo "noinst_HEADERS ="
    echo "noinst_LIBRARIES ="
    echo "noinst_LTLIBRARIES ="
    # Automake versions < 1.11.4 create an empty pkgdatadir at
    # installation time if you specify pkgdata_DATA to empty.
    # See automake bugs #10997 and #11030:
    #  * https://debbugs.gnu.org/10997
    #  * https://debbugs.gnu.org/11030
    # So we need this workaround.
    if grep '^pkgdata_DATA *+=' "$tmp"/allsnippets > /dev/null; then
      echo "pkgdata_DATA ="
    fi
    echo "EXTRA_DIST ="
    echo "BUILT_SOURCES ="
    echo "SUFFIXES ="
  fi
  echo "MOSTLYCLEANFILES $assign core *.stackdump"
  if test -z "$makefile_name"; then
    echo "MOSTLYCLEANDIRS ="
    echo "CLEANFILES ="
    echo "DISTCLEANFILES ="
    echo "MAINTAINERCLEANFILES ="
  fi
  if $gnu_make; then
    echo "# Start of GNU Make output."

    # Put autoconf output into a temporary file, so that its exit status
    # can be checked from the shell.  Signal any error by putting a
    # syntax error into the output makefile.
    ${AUTOCONF} -t 'AC_SUBST:$1 = @$1@' "$configure_ac" \
                >"$tmp"/makeout 2>"$tmp"/makeout2 &&
      LC_ALL=C sort -u "$tmp"/makeout || {
        echo "== gnulib-tool GNU Make output failed as follows =="
        sed 's/^/# stderr: /' "$tmp"/makeout2
      }
    rm -f "$tmp"/makeout "$tmp"/makeout2

    echo "# End of GNU Make output."
  else
    echo "# No GNU Make output."
  fi
  # Execute edits that apply to the Makefile.am being generated.
  edit=0
  while test $edit != $makefile_am_edits; do
    edit=`expr $edit + 1`
    eval dir=\"\$makefile_am_edit${edit}_dir\"
    eval var=\"\$makefile_am_edit${edit}_var\"
    eval val=\"\$makefile_am_edit${edit}_val\"
    eval dotfirst=\"\$makefile_am_edit${edit}_dotfirst\"
    if test -n "$var"; then
      if test "${dir}Makefile.am" = "$destfile" || test "./${dir}Makefile.am" = "$destfile"; then
        if test "${var}" = SUBDIRS && test -n "$dotfirst"; then
          # The added subdirectory ${val} needs to be mentioned after '.'.
          # Since we don't have '.' among SUBDIRS so far, add it now.
          val=". ${val}"
        fi
        echo "${var} += ${val}"
        eval "makefile_am_edit${edit}_var="
      fi
    fi
  done
  if test -n "$witness_c_macro"; then
    cppflags_part1=" -D$witness_c_macro=1"
  else
    cppflags_part1=
  fi
  if $for_test; then
    cppflags_part2=" -DGNULIB_STRICT_CHECKING=1"
  else
    cppflags_part2=
  fi
  if test -z "$makefile_name"; then
    echo
    echo "AM_CPPFLAGS =$cppflags_part1$cppflags_part2"
    echo "AM_CFLAGS ="
  else
    if test -n "$cppflags_part1$cppflags_part2"; then
      echo
      echo "AM_CPPFLAGS +=$cppflags_part1$cppflags_part2"
    fi
  fi
  echo
  if LC_ALL=C grep "^[a-zA-Z0-9_]*_${perhapsLT}LIBRARIES *+\{0,1\}= *$libname\\.$libext\$" "$tmp"/allsnippets > /dev/null \
     || { test -n "$makefile_name" \
          && test -f "$sourcebase/Makefile.am" \
          && LC_ALL=C grep "^[a-zA-Z0-9_]*_${perhapsLT}LIBRARIES *+\{0,1\}= *$libname\\.$libext\$" "$sourcebase/Makefile.am" > /dev/null; \
        }; then
    # One of the snippets or the user's Makefile.am already specifies an
    # installation location for the library. Don't confuse automake by saying
    # it should not be installed.
    :
  else
    # By default, the generated library should not be installed.
    echo "noinst_${perhapsLT}LIBRARIES += $libname.$libext"
  fi
  echo
  echo "${libname}_${libext}_SOURCES ="
  # Here we use $(LIBOBJS), not @LIBOBJS@. The value is the same. However,
  # automake during its analysis looks for $(LIBOBJS), not for @LIBOBJS@.
  echo "${libname}_${libext}_LIBADD = \$(${macro_prefix}_${perhapsLT}LIBOBJS)"
  echo "${libname}_${libext}_DEPENDENCIES = \$(${macro_prefix}_${perhapsLT}LIBOBJS)"
  echo "EXTRA_${libname}_${libext}_SOURCES ="
  if test "$libtool" = true; then
    echo "${libname}_${libext}_LDFLAGS = \$(AM_LDFLAGS)"
    echo "${libname}_${libext}_LDFLAGS += -no-undefined"
    # Synthesize an ${libname}_${libext}_LDFLAGS augmentation by combining
    # the link dependencies of all modules.
    for module in $modules; do
      func_verify_nontests_module
      if test -n "$module"; then
        func_get_link_directive "$module"
      fi
    done \
      | LC_ALL=C sed -e '/^$/d' -e 's/ when linking with libtool.*//' \
      | LC_ALL=C sort -u \
      | LC_ALL=C sed -e 's/^/'"${libname}_${libext}"'_LDFLAGS += /'
  fi
  echo
  if test -n "$pobase"; then
    echo "AM_CPPFLAGS += -DDEFAULT_TEXT_DOMAIN=\\\"${po_domain}-gnulib\\\""
    echo
  fi
  cat "$tmp"/allsnippets \
    | sed -e 's|\$(top_srcdir)/build-aux/|$(top_srcdir)/'"$auxdir"'/|g'
  echo
  echo "mostlyclean-local: mostlyclean-generic"
  echo "        @for dir in '' \$(MOSTLYCLEANDIRS); do \\"
  echo "          if test -n \"\$\$dir\" && test -d \$\$dir; then \\"
  echo "            echo \"rmdir \$\$dir\"; rmdir \$\$dir; \\"
  echo "          fi; \\"
  echo "        done; \\"
  echo "        :"
  rm -f "$tmp"/allsnippets
}

# func_emit_po_Makevars
# emits the contents of po/ makefile parameterization to standard output.
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - sourcebase      directory relative to destdir where to place source code
# - pobase          directory relative to destdir where to place *.po files
# - po_domain       prefix of i18n domain to use (without -gnulib suffix)
func_emit_po_Makevars ()
{
  echo "## DO NOT EDIT! GENERATED AUTOMATICALLY!"
  func_emit_copyright_notice
  echo
  echo "# Usually the message domain is the same as the package name."
  echo "# But here it has a '-gnulib' suffix."
  echo "DOMAIN = ${po_domain}-gnulib"
  echo
  echo "# These two variables depend on the location of this directory."
  echo "subdir = ${pobase}"
  echo "top_builddir = "`echo "$pobase" | sed -e 's,//*,/,g' -e 's,[^/][^/]*,..,g'`
  echo
  cat <<\EOF
# These options get passed to xgettext.
XGETTEXT_OPTIONS = \
  --keyword=_ --flag=_:1:pass-c-format \
  --keyword=N_ --flag=N_:1:pass-c-format \
  --keyword='proper_name:1,"This is a proper name. See the gettext manual, section Names."' \
  --keyword='proper_name_utf8:1,"This is a proper name. See the gettext manual, section Names."' \
  --flag=error:3:c-format --flag=error_at_line:5:c-format

# This is the copyright holder that gets inserted into the header of the
# $(DOMAIN).pot file.  gnulib is copyrighted by the FSF.
COPYRIGHT_HOLDER = Free Software Foundation, Inc.

# This is the email address or URL to which the translators shall report
# bugs in the untranslated strings:
# - Strings which are not entire sentences, see the maintainer guidelines
#   in the GNU gettext documentation, section 'Preparing Strings'.
# - Strings which use unclear terms or require additional context to be
#   understood.
# - Strings which make invalid assumptions about notation of date, time or
#   money.
# - Pluralisation problems.
# - Incorrect English spelling.
# - Incorrect formatting.
# It can be your email address, or a mailing list address where translators
# can write to without being subscribed, or the URL of a web page through
# which the translators can contact you.
MSGID_BUGS_ADDRESS = bug-gnulib@gnu.org

# This is the list of locale categories, beyond LC_MESSAGES, for which the
# message catalogs shall be used.  It is usually empty.
EXTRA_LOCALE_CATEGORIES =

# This tells whether the $(DOMAIN).pot file contains messages with an 'msgctxt'
# context.  Possible values are "yes" and "no".  Set this to yes if the
# package uses functions taking also a message context, like pgettext(), or
# if in $(XGETTEXT_OPTIONS) you define keywords with a context argument.
USE_MSGCTXT = no
EOF
}

# func_emit_po_POTFILES_in
# emits the file list to be passed to xgettext to standard output.
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - sourcebase      directory relative to destdir where to place source code
# - files           list of new files
func_emit_po_POTFILES_in ()
{
  echo "## DO NOT EDIT! GENERATED AUTOMATICALLY!"
  func_emit_copyright_notice
  echo
  echo "# List of files which contain translatable strings."
  echo "$files" | sed -n -e "s,^lib/,$sourcebase/,p"
}

# func_emit_tests_Makefile_am witness_macro
# emits the contents of tests makefile to standard output.
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - modules         list of modules, including dependencies
# - libname         library name
# - auxdir          directory relative to destdir where to place build aux files
# - gnu_make        true if --gnu-make was given, false otherwise
# - makefile_name   from --makefile-name
# - libtool         true if libtool will be used, false or blank otherwise
# - sourcebase      relative directory containing lib source code
# - m4base          relative directory containing autoconf macros
# - testsbase       relative directory containing unit test code
# - macro_prefix    prefix of gl_LIBOBJS macros to use
# - witness_c_macro  from --witness-c-macro
# - for_test        true if creating a package for testing, false otherwise
# - single_configure  true if a single configure file should be generated,
#                     false for a separate configure file for the tests
# - use_libtests    true if a libtests.a should be built, false otherwise
# - sed_replace_include_guard_prefix
#                   sed expression for resolving ${gl_include_guard_prefix}
# - destfile        filename relative to destdir of makefile being generated
# Input/Output:
# - makefile_am_edits and makefile_am_edit${edit}_{dir,var,val,dotfirst}
#                   list of edits to be done to Makefile.am variables
# Output:
# - uses_subdirs    nonempty if object files in subdirs exist
func_emit_tests_Makefile_am ()
{
  witness_macro="$1"
  if test "$libtool" = true; then
    libext=la
    perhapsLT=LT
    sed_eliminate_LDFLAGS="$sed_noop"
  else
    libext=a
    perhapsLT=
    sed_eliminate_LDFLAGS='/^lib_LDFLAGS[        ]*+=/d'
  fi
  if $for_test; then
    # When creating a package for testing: Attempt to provoke failures,
    # especially link errors, already during "make" rather than during
    # "make check", because "make check" is not possible in a cross-compiling
    # situation. Turn check_PROGRAMS into noinst_PROGRAMS.
    sed_transform_check_PROGRAMS='s,check_PROGRAMS,noinst_PROGRAMS,g'
  else
    sed_transform_check_PROGRAMS="$sed_noop"
  fi
  testsbase_inverse=`echo "$testsbase" | sed -e 's,/$,,' | sed -e 's,[^/][^/]*,..,g'`
  echo "## DO NOT EDIT! GENERATED AUTOMATICALLY!"
  echo "## Process this file with automake to produce Makefile.in."
  func_emit_copyright_notice
  echo
  uses_subdirs=
  {
    for module in $modules; do
      if $for_test && ! $single_configure; then
        func_verify_tests_module
      else
        func_verify_module
      fi
      if test -n "$module"; then
        {
          func_get_automake_snippet_conditional "$module" |
            LC_ALL=C \
            sed -e 's,lib_LIBRARIES,lib%_LIBRARIES,g' \
                -e 's,lib_LTLIBRARIES,lib%_LTLIBRARIES,g' \
                -e "$sed_eliminate_LDFLAGS" \
                -e 's,lib_\([A-Z][A-Z]*\),libtests_a_\1,g' \
                -e 's,lib%_LIBRARIES,lib_LIBRARIES,g' \
                -e 's,lib%_LTLIBRARIES,lib_LTLIBRARIES,g' \
                -e "$sed_transform_check_PROGRAMS" \
                -e "$sed_replace_include_guard_prefix"
          if $use_libtests && test "$module" = 'alloca'; then
            echo "libtests_a_LIBADD += @ALLOCA@"
            echo "libtests_a_DEPENDENCIES += @ALLOCA@"
          fi
        } | combine_lines "libtests_a_SOURCES" > "$tmp"/amsnippet1
        {
          func_get_automake_snippet_unconditional "$module" |
            LC_ALL=C sed -e 's,lib_\([A-Z][A-Z]*\),libtests_a_\1,g'
        } > "$tmp"/amsnippet2
        # Skip the contents if it's entirely empty.
        if grep '[^      ]' "$tmp"/amsnippet1 "$tmp"/amsnippet2 > /dev/null ; then
          # Mention long-running tests at the end.
          ofd=3
          for word in `func_get_status "$module"`; do
            if test "$word" = 'longrunning-test'; then
              ofd=4
              break
            fi
          done
          { echo "## begin gnulib module $module"
            if $gnu_make; then
              echo "ifeq (,\$(OMIT_GNULIB_MODULE_$module))"
              convert_to_gnu_make='s/^if \(.*\)/ifneq (,$(\1))/'
            else
              convert_to_gnu_make=
            fi
            echo
            if test "$cond_dependencies" = true; then
              if func_cond_module_p "$module"; then
                func_module_conditional_name "$module"
                if $gnu_make; then
                  echo "ifneq (,\$($conditional))"
                else
                  echo "if $conditional"
                fi
              fi
            fi
            sed "$convert_to_gnu_make" "$tmp"/amsnippet1
            if test "$cond_dependencies" = true; then
              if func_cond_module_p "$module"; then
                echo "endif"
              fi
            fi
            sed "$convert_to_gnu_make" "$tmp"/amsnippet2
            if $gnu_make; then
              echo "endif"
            fi
            echo "## end   gnulib module $module"
            echo
          } >&$ofd
        fi
        rm -f "$tmp"/amsnippet1 "$tmp"/amsnippet2
        # Test whether there are some source files in subdirectories.
        for f in `func_get_filelist "$module"`; do
          case $f in
            lib/*/*.c | tests/*/*.c)
              uses_subdirs=yes
              break
              ;;
          esac
        done
      fi
    done
  } 3> "$tmp"/main_snippets 4> "$tmp"/longrunning_snippets
  # Generate dependencies here, since it eases the debugging of test failures.
  # If there are source files in subdirectories, prevent collision of the
  # object files (example: hash.c and libxml/hash.c).
  subdir_options=
  if test -n "$uses_subdirs"; then
    subdir_options=' subdir-objects'
  fi
  echo "AUTOMAKE_OPTIONS = 1.11 foreign${subdir_options}"
  echo
  if $for_test && ! $single_configure; then
    echo "ACLOCAL_AMFLAGS = -I ${testsbase_inverse}/${m4base}"
    echo
  fi
  # Nothing is being added to SUBDIRS; nevertheless the existence of this
  # variable is needed to avoid an error from automake:
  #   "AM_GNU_GETTEXT used but SUBDIRS not defined"
  echo "SUBDIRS = ."
  echo "TESTS ="
  echo "XFAIL_TESTS ="
  echo "TESTS_ENVIRONMENT ="
  echo "noinst_PROGRAMS ="
  if ! $for_test; then
    echo "check_PROGRAMS ="
  fi
  echo "EXTRA_PROGRAMS ="
  echo "noinst_HEADERS ="
  echo "noinst_LIBRARIES ="
  if $use_libtests; then
    if $for_test; then
      echo "noinst_LIBRARIES += libtests.a"
    else
      echo "check_LIBRARIES = libtests.a"
    fi
  fi
  # Automake versions < 1.11.4 create an empty pkgdatadir at
  # installation time if you specify pkgdata_DATA to empty.
  # See automake bugs #10997 and #11030:
  #  * https://debbugs.gnu.org/10997
  #  * https://debbugs.gnu.org/11030
  # So we need this workaround.
  if grep '^pkgdata_DATA *+=' "$tmp"/main_snippets "$tmp"/longrunning_snippets > /dev/null; then
    echo "pkgdata_DATA ="
  fi
  echo "EXTRA_DIST ="
  echo "BUILT_SOURCES ="
  echo "SUFFIXES ="
  echo "MOSTLYCLEANFILES = core *.stackdump"
  echo "MOSTLYCLEANDIRS ="
  echo "CLEANFILES ="
  echo "DISTCLEANFILES ="
  echo "MAINTAINERCLEANFILES ="
  # Execute edits that apply to the Makefile.am being generated.
  edit=0
  while test $edit != $makefile_am_edits; do
    edit=`expr $edit + 1`
    eval dir=\"\$makefile_am_edit${edit}_dir\"
    eval var=\"\$makefile_am_edit${edit}_var\"
    eval val=\"\$makefile_am_edit${edit}_val\"
    eval dotfirst=\"\$makefile_am_edit${edit}_dotfirst\"
    if test -n "$var"; then
      if test "${dir}Makefile.am" = "$destfile" || test "./${dir}Makefile.am" = "$destfile"; then
        if test "${var}" = SUBDIRS && test -n "$dotfirst"; then
          # The added subdirectory ${val} needs to be mentioned after '.'.
          # But we have '.' among SUBDIRS already, so do nothing.
          :
        fi
        echo "${var} += ${val}"
        eval "makefile_am_edit${edit}_var="
      fi
    fi
  done
  echo
  echo "AM_CPPFLAGS = \\"
  if $for_test; then
    echo "  -DGNULIB_STRICT_CHECKING=1 \\"
  fi
  if test -n "$witness_c_macro"; then
    echo "  -D$witness_c_macro=1 \\"
  fi
  if test -n "${witness_macro}"; then
    echo "  -D@${witness_macro}@=1 \\"
  fi
  echo "  -I. -I\$(srcdir) \\"
  echo "  -I${testsbase_inverse} -I\$(srcdir)/${testsbase_inverse} \\"
  echo "  -I${testsbase_inverse}/${sourcebase-lib} -I\$(srcdir)/${testsbase_inverse}/${sourcebase-lib}"
  echo
  if $use_libtests; then
    # All test programs need to be linked with libtests.a.
    # It needs to be passed to the linker before ${libname}.${libext}, since
    # the tests-related modules depend on the main modules.
    # It also needs to be passed to the linker after ${libname}.${libext}
    # because the latter might contain incomplete modules (such as the
    # 'version-etc' module whose dependency to 'version-etc-fsf' is voluntarily
    # omitted).
    # The LIBTESTS_LIBDEPS can be passed to the linker once or twice, it does
    # not matter.
    echo "LDADD = libtests.a ${testsbase_inverse}/${sourcebase-lib}/${libname}.${libext} libtests.a ${testsbase_inverse}/${sourcebase-lib}/${libname}.${libext} libtests.a \$(LIBTESTS_LIBDEPS)"
  else
    echo "LDADD = ${testsbase_inverse}/${sourcebase-lib}/${libname}.${libext}"
  fi
  echo
  if $use_libtests; then
    echo "libtests_a_SOURCES ="
    # Here we use $(LIBOBJS), not @LIBOBJS@. The value is the same. However,
    # automake during its analysis looks for $(LIBOBJS), not for @LIBOBJS@.
    echo "libtests_a_LIBADD = \$(${macro_prefix}tests_LIBOBJS)"
    echo "libtests_a_DEPENDENCIES = \$(${macro_prefix}tests_LIBOBJS)"
    echo "EXTRA_libtests_a_SOURCES ="
    # The circular dependency in LDADD requires this.
    echo "AM_LIBTOOLFLAGS = --preserve-dup-deps"
    echo
  fi
  # Many test scripts use ${EXEEXT} or ${srcdir}.
  # EXEEXT is defined by AC_PROG_CC through autoconf.
  # srcdir is defined by autoconf and automake.
  echo "TESTS_ENVIRONMENT += EXEEXT='@EXEEXT@' srcdir='\$(srcdir)'"
  echo
  cat "$tmp"/main_snippets "$tmp"/longrunning_snippets \
    | sed -e 's|\$(top_srcdir)/build-aux/|$(top_srcdir)/'"$auxdir"'/|g'
  echo "# Clean up after Solaris cc."
  echo "clean-local:"
  echo "        rm -rf SunWS_cache"
  echo
  echo "mostlyclean-local: mostlyclean-generic"
  echo "        @for dir in '' \$(MOSTLYCLEANDIRS); do \\"
  echo "          if test -n \"\$\$dir\" && test -d \$\$dir; then \\"
  echo "            echo \"rmdir \$\$dir\"; rmdir \$\$dir; \\"
  echo "          fi; \\"
  echo "        done; \\"
  echo "        :"
  rm -f "$tmp"/main_snippets "$tmp"/longrunning_snippets
}

# func_emit_initmacro_start macro_prefix
# emits the first few statements of the gl_INIT macro to standard output.
# - macro_prefix    prefix of gl_EARLY, gl_INIT macros to use
func_emit_initmacro_start ()
{
  macro_prefix_arg="$1"
  # Overriding AC_LIBOBJ and AC_REPLACE_FUNCS has the effect of storing
  # platform-dependent object files in ${macro_prefix_arg}_LIBOBJS instead of
  # LIBOBJS.  The purpose is to allow several gnulib instantiations under
  # a single configure.ac file.  (AC_CONFIG_LIBOBJ_DIR does not allow this
  # flexibility.)
  # Furthermore it avoids an automake error like this when a Makefile.am
  # that uses pieces of gnulib also uses $(LIBOBJ):
  #   automatically discovered file `error.c' should not be explicitly mentioned
  echo "  m4_pushdef([AC_LIBOBJ], m4_defn([${macro_prefix_arg}_LIBOBJ]))"
  echo "  m4_pushdef([AC_REPLACE_FUNCS], m4_defn([${macro_prefix_arg}_REPLACE_FUNCS]))"
  # Overriding AC_LIBSOURCES has the same purpose of avoiding the automake
  # error when a Makefile.am that uses pieces of gnulib also uses $(LIBOBJ):
  #   automatically discovered file `error.c' should not be explicitly mentioned
  # We let automake know about the files to be distributed through the
  # EXTRA_lib_SOURCES variable.
  echo "  m4_pushdef([AC_LIBSOURCES], m4_defn([${macro_prefix_arg}_LIBSOURCES]))"
  # Create data variables for checking the presence of files that are mentioned
  # as AC_LIBSOURCES arguments. These are m4 variables, not shell variables,
  # because we want the check to happen when the configure file is created,
  # not when it is run. ${macro_prefix_arg}_LIBSOURCES_LIST is the list of
  # files to check for. ${macro_prefix_arg}_LIBSOURCES_DIR is the subdirectory
  # in which to expect them.
  echo "  m4_pushdef([${macro_prefix_arg}_LIBSOURCES_LIST], [])"
  echo "  m4_pushdef([${macro_prefix_arg}_LIBSOURCES_DIR], [])"
  echo "  gl_COMMON"
}

# func_emit_initmacro_end macro_prefix
# emits the last few statements of the gl_INIT macro to standard output.
# - macro_prefix    prefix of gl_EARLY, gl_INIT macros to use
func_emit_initmacro_end ()
{
  macro_prefix_arg="$1"
  # Check the presence of files that are mentioned as AC_LIBSOURCES arguments.
  # The check is performed only when autoconf is run from the directory where
  # the configure.ac resides; if it is run from a different directory, the
  # check is skipped.
  echo "  m4_ifval(${macro_prefix_arg}_LIBSOURCES_LIST, ["
  echo "    m4_syscmd([test ! -d ]m4_defn([${macro_prefix_arg}_LIBSOURCES_DIR])[ ||"
  echo "      for gl_file in ]${macro_prefix_arg}_LIBSOURCES_LIST[ ; do"
  echo "        if test ! -r ]m4_defn([${macro_prefix_arg}_LIBSOURCES_DIR])[/\$gl_file ; then"
  echo "          echo \"missing file ]m4_defn([${macro_prefix_arg}_LIBSOURCES_DIR])[/\$gl_file\" >&2"
  echo "          exit 1"
  echo "        fi"
  echo "      done])dnl"
  echo "      m4_if(m4_sysval, [0], [],"
  echo "        [AC_FATAL([expected source file, required through AC_LIBSOURCES, not found])])"
  echo "  ])"
  echo "  m4_popdef([${macro_prefix_arg}_LIBSOURCES_DIR])"
  echo "  m4_popdef([${macro_prefix_arg}_LIBSOURCES_LIST])"
  echo "  m4_popdef([AC_LIBSOURCES])"
  echo "  m4_popdef([AC_REPLACE_FUNCS])"
  echo "  m4_popdef([AC_LIBOBJ])"
  echo "  AC_CONFIG_COMMANDS_PRE(["
  echo "    ${macro_prefix_arg}_libobjs="
  echo "    ${macro_prefix_arg}_ltlibobjs="
  echo "    if test -n \"\$${macro_prefix_arg}_LIBOBJS\"; then"
  echo "      # Remove the extension."
  echo "      sed_drop_objext='s/\\.o\$//;s/\\.obj\$//'"
  echo "      for i in \`for i in \$${macro_prefix_arg}_LIBOBJS; do echo \"\$i\"; done | sed -e \"\$sed_drop_objext\" | sort | uniq\`; do"
  echo "        ${macro_prefix_arg}_libobjs=\"\$${macro_prefix_arg}_libobjs \$i.\$ac_objext\""
  echo "        ${macro_prefix_arg}_ltlibobjs=\"\$${macro_prefix_arg}_ltlibobjs \$i.lo\""
  echo "      done"
  echo "    fi"
  echo "    AC_SUBST([${macro_prefix_arg}_LIBOBJS], [\$${macro_prefix_arg}_libobjs])"
  echo "    AC_SUBST([${macro_prefix_arg}_LTLIBOBJS], [\$${macro_prefix_arg}_ltlibobjs])"
  echo "  ])"
}

# func_emit_initmacro_done macro_prefix sourcebase
# emits a few statements after the gl_INIT macro to standard output.
# - macro_prefix    prefix of gl_EARLY, gl_INIT macros to use
# - sourcebase      directory relative to destdir where to place source code
func_emit_initmacro_done ()
{
  macro_prefix_arg="$1"
  sourcebase_arg="$2"
  echo
  echo "# Like AC_LIBOBJ, except that the module name goes"
  echo "# into ${macro_prefix_arg}_LIBOBJS instead of into LIBOBJS."
  echo "AC_DEFUN([${macro_prefix_arg}_LIBOBJ], ["
  echo "  AS_LITERAL_IF([\$1], [${macro_prefix_arg}_LIBSOURCES([\$1.c])])dnl"
  echo "  ${macro_prefix_arg}_LIBOBJS=\"\$${macro_prefix_arg}_LIBOBJS \$1.\$ac_objext\""
  echo "])"
  echo
  echo "# Like AC_REPLACE_FUNCS, except that the module name goes"
  echo "# into ${macro_prefix_arg}_LIBOBJS instead of into LIBOBJS."
  echo "AC_DEFUN([${macro_prefix_arg}_REPLACE_FUNCS], ["
  echo "  m4_foreach_w([gl_NAME], [\$1], [AC_LIBSOURCES(gl_NAME[.c])])dnl"
  echo "  AC_CHECK_FUNCS([\$1], , [${macro_prefix_arg}_LIBOBJ(\$ac_func)])"
  echo "])"
  echo
  echo "# Like AC_LIBSOURCES, except the directory where the source file is"
  echo "# expected is derived from the gnulib-tool parameterization,"
  echo "# and alloca is special cased (for the alloca-opt module)."
  echo "# We could also entirely rely on EXTRA_lib..._SOURCES."
  echo "AC_DEFUN([${macro_prefix_arg}_LIBSOURCES], ["
  echo "  m4_foreach([_gl_NAME], [\$1], ["
  echo "    m4_if(_gl_NAME, [alloca.c], [], ["
  echo "      m4_define([${macro_prefix_arg}_LIBSOURCES_DIR], [$sourcebase_arg])"
  echo "      m4_append([${macro_prefix_arg}_LIBSOURCES_LIST], _gl_NAME, [ ])"
  echo "    ])"
  echo "  ])"
  echo "])"
}

# func_emit_autoconf_snippet indentation
# emits the autoconf snippet of a module.
# Input:
# - indentation       spaces to prepend on each line
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
# - sed_replace_build_aux  sed expression that replaces reference to build-aux
# - sed_replace_include_guard_prefix
#                     sed expression for resolving ${gl_include_guard_prefix}
# - module            the module name
# - toplevel          true or false. 'false' means a subordinate use of
#                     gnulib-tool.
# - disable_libtool   true or false. It tells whether to disable libtool
#                     handling even if it has been specified through the
#                     command line options.
# - disable_gettext   true or false. It tells whether to disable AM_GNU_GETTEXT
#                     invocations.
func_emit_autoconf_snippet ()
{
  indentation="$1"
  if { case $module in
         gnumakefile | maintainer-makefile)
           # These modules are meant to be used only in the top-level directory.
           $toplevel ;;
         *)
           true ;;
       esac
     }; then
    func_get_autoconf_snippet "$module" \
      | sed -e '/^$/d;' -e "s/^/$indentation/" \
            -e "$sed_replace_build_aux" \
            -e "$sed_replace_include_guard_prefix" \
      | { if $disable_libtool; then
            sed -e 's/\$gl_cond_libtool/false/g' \
                -e 's/gl_libdeps/gltests_libdeps/g' \
                -e 's/gl_ltlibdeps/gltests_ltlibdeps/g'
          else
            cat
          fi
        } \
      | { if $disable_gettext; then
            sed -e 's/AM_GNU_GETTEXT(\[external\])/dnl you must add AM_GNU_GETTEXT([external]) or similar to configure.ac./'
          else
            # Don't indent AM_GNU_GETTEXT_VERSION line, as that confuses
            # autopoint through at least GNU gettext version 0.18.2.
            sed -e 's/^ *AM_GNU_GETTEXT_VERSION/AM_GNU_GETTEXT_VERSION/'
          fi
        }
    if test "$module" = 'alloca' && test "$libtool" = true && ! $disable_libtool; then
      echo 'changequote(,)dnl'
      echo 'LTALLOCA=`echo "$ALLOCA" | sed -e '"'"'s/\.[^.]* /.lo /g;s/\.[^.]*$/.lo/'"'"'`'
      echo 'changequote([, ])dnl'
      echo 'AC_SUBST([LTALLOCA])'
    fi
  fi
}

# func_emit_autoconf_snippets modules referenceable_modules verifier toplevel disable_libtool disable_gettext
# collects and emit the autoconf snippets of a set of modules.
# Input:
# - local_gnulib_path  from --local-dir
# - modcache          true or false, from --cache-modules/--no-cache-modules
# - sed_replace_build_aux  sed expression that replaces reference to build-aux
# - sed_replace_include_guard_prefix
#                     sed expression for resolving ${gl_include_guard_prefix}
# - modules           the list of modules.
# - referenceable_modules  the list of modules which may be referenced as dependencies.
# - verifier          one of func_verify_module, func_verify_nontests_module,
#                     func_verify_tests_module. It selects the subset of
#                     $modules to consider.
# - toplevel          true or false. 'false' means a subordinate use of
#                     gnulib-tool.
# - disable_libtool   true or false. It tells whether to disable libtool
#                     handling even if it has been specified through the
#                     command line options.
# - disable_gettext   true or false. It tells whether to disable AM_GNU_GETTEXT
#                     invocations.
func_emit_autoconf_snippets ()
{
  referenceable_modules="$2"
  verifier="$3"
  toplevel="$4"
  disable_libtool="$5"
  disable_gettext="$6"
  if test "$cond_dependencies" = true; then
    for m in $referenceable_modules; do echo $m; done | LC_ALL=C sort -u > "$tmp"/modules
    # Emit the autoconf code for the unconditional modules.
    for module in $1; do
      eval $verifier
      if test -n "$module"; then
        if func_cond_module_p "$module"; then
          :
        else
          func_emit_autoconf_snippet "  "
        fi
      fi
    done
    # Initialize the shell variables indicating that the modules are enabled.
    for module in $1; do
      eval $verifier
      if test -n "$module"; then
        if func_cond_module_p "$module"; then
          func_module_shellvar_name "$module"
          echo "  $shellvar=false"
        fi
      fi
    done
    # Emit the autoconf code for the conditional modules, each in a separate
    # function. This makes it possible to support cycles among conditional
    # modules.
    for module in $1; do
      eval $verifier
      if test -n "$module"; then
        if func_cond_module_p "$module"; then
          func_module_shellfunc_name "$module"
          func_module_shellvar_name "$module"
          echo "  $shellfunc ()"
          echo '  {'
          echo "    if ! \$$shellvar; then"
          func_emit_autoconf_snippet "      "
          echo "      $shellvar=true"
          deps=`func_get_dependencies $module | sed -e "$sed_dependencies_without_conditions"`
          # Intersect $deps with the modules list $1.
          deps=`for m in $deps; do echo $m; done | LC_ALL=C sort -u | LC_ALL=C join - "$tmp"/modules`
          for dep in $deps; do
            if func_cond_module_p "$dep"; then
              func_module_shellfunc_name "$dep"
              func_cond_module_condition "$module" "$dep"
              if test "$condition" != true; then
                echo "      if $condition; then"
                echo "        $shellfunc"
                echo '      fi'
              else
                echo "      $shellfunc"
              fi
            else
              # The autoconf code for $dep has already been emitted above and
              # therefore is already executed when this function is run.
              :
            fi
          done
          echo '    fi'
          echo '  }'
        fi
      fi
    done
    # Emit the dependencies from the unconditional to the conditional modules.
    for module in $1; do
      eval $verifier
      if test -n "$module"; then
        if func_cond_module_p "$module"; then
          :
        else
          deps=`func_get_dependencies $module | sed -e "$sed_dependencies_without_conditions"`
          # Intersect $deps with the modules list $1.
          deps=`for m in $deps; do echo $m; done | LC_ALL=C sort -u | LC_ALL=C join - "$tmp"/modules`
          for dep in $deps; do
            if func_cond_module_p "$dep"; then
              func_module_shellfunc_name "$dep"
              func_cond_module_condition "$module" "$dep"
              if test "$condition" != true; then
                echo "  if $condition; then"
                echo "    $shellfunc"
                echo '  fi'
              else
                echo "  $shellfunc"
              fi
            else
              # The autoconf code for $dep has already been emitted above and
              # therefore is already executed when this code is run.
              :
            fi
          done
        fi
      fi
    done
    # Define the Automake conditionals.
    echo "  m4_pattern_allow([^${macro_prefix}_GNULIB_ENABLED_])"
    for module in $1; do
      eval $verifier
      if test -n "$module"; then
        if func_cond_module_p "$module"; then
          func_module_conditional_name "$module"
          func_module_shellvar_name "$module"
          echo "  AM_CONDITIONAL([$conditional], [\$$shellvar])"
        fi
      fi
    done
  else
    # Ignore the conditions, and enable all modules unconditionally.
    for module in $1; do
      eval $verifier
      if test -n "$module"; then
        func_emit_autoconf_snippet "  "
      fi
    done
  fi
}

# func_emit_pre_early_macros require indentation modules
# The require parameter can be ':' (AC_REQUIRE) or 'false' (direct call).
func_emit_pre_early_macros ()
{
  echo
  echo "${2}# Pre-early section."
  if $1; then
    _pre_early_snippet="echo \"${2}AC_REQUIRE([\$_pre_early_macro])\""
  else
    _pre_early_snippet="echo \"${2}\$_pre_early_macro\""
  fi

  # We need to call gl_USE_SYSTEM_EXTENSIONS before gl_PROG_AR_RANLIB.  Doing
  # AC_REQUIRE in configure-ac.early is not early enough.
  _pre_early_macro="gl_USE_SYSTEM_EXTENSIONS"
  case "${nl}${3}${nl}" in
    *${nl}extensions${nl}*) eval "$_pre_early_snippet" ;;
  esac

  _pre_early_macro="gl_PROG_AR_RANLIB"
  eval "$_pre_early_snippet"
  echo
}

# func_reconstruct_cached_dir
# callback for func_reconstruct_cached_local_gnulib_path
# Input:
# - destdir         from --dir
# Output:
# - local_gnulib_path  restored '--local-dir' path from cache
func_reconstruct_cached_dir ()
{
  cached_dir=$1
  if test -n "$cached_dir"; then
    case "$destdir" in
      /*)
        func_path_append local_gnulib_path "$destdir/$cached_dir" ;;
      *)
        case "$cached_dir" in
          /*)
            func_path_append local_gnulib_path "$destdir/$cached_dir" ;;
          *)
            func_relconcat "$destdir" "$cached_dir"
            func_path_append local_gnulib_path "$relconcat" ;;
        esac ;;
    esac
  fi
}

# func_reconstruct_cached_local_gnulib_path
# reconstruct local_gnulib_path from cached_local_gnulib_path to be set
# relatively to $destdir again.
# Input:
# - cached_local_gnulib_path  local_gnulib_path stored within gnulib-cache.m4
# - destdir         from --dir
# Output:
# - local_gnulib_path  restored '--local-dir' path from cache
func_reconstruct_cached_local_gnulib_path ()
{
  func_path_foreach "$cached_local_gnulib_path" func_reconstruct_cached_dir %dir%
}

# func_import modules
# Uses also the variables
# - mode            import or add-import or remove-import or update
# - destdir         target directory
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - verbose         integer, default 0, inc/decremented by --verbose/--quiet
# - libname         library name
# - supplied_libname  true if --lib was given, blank otherwise
# - sourcebase      directory relative to destdir where to place source code
# - m4base          directory relative to destdir where to place *.m4 macros
# - pobase          directory relative to destdir where to place *.po files
# - docbase         directory relative to destdir where to place doc files
# - testsbase       directory relative to destdir where to place unit test code
# - auxdir          directory relative to destdir where to place build aux files
# - inctests        true if --with-tests was given, false otherwise
# - incobsolete     true if --with-obsolete was given, blank otherwise
# - inc_cxx_tests   true if --with-c++-tests was given, blank otherwise
# - inc_longrunning_tests  true if --with-longrunning-tests was given, blank
#                          otherwise
# - inc_privileged_tests  true if --with-privileged-tests was given, blank
#                         otherwise
# - inc_unportable_tests  true if --with-unportable-tests was given, blank
#                         otherwise
# - inc_all_tests   true if --with-all-tests was given, blank otherwise
# - avoidlist       list of modules to avoid, from --avoid
# - cond_dependencies  true if --conditional-dependencies was given, false if
#                      --no-conditional-dependencies was given, blank otherwise
# - lgpl            yes or a number if library's license shall be LGPL,
#                   blank otherwise
# - makefile_name   from --makefile-name
# - libtool         true if --libtool was given, false if --no-libtool was
#                   given, blank otherwise
# - guessed_libtool true if the configure.ac file uses libtool, false otherwise
# - macro_prefix    prefix of gl_EARLY, gl_INIT macros to use
# - po_domain       prefix of i18n domain to use (without -gnulib suffix)
# - witness_c_macro  from --witness-c-macro
# - vc_files        true if --vc-files was given, false if --no-vc-files was
#                   given, blank otherwise
# - autoconf_minversion  minimum supported autoconf version
# - doit            : if actions shall be executed, false if only to be printed
# - copymode        copy mode for files in general
# - lcopymode       copy mode for files from local_gnulib_path
# - do_copyrights   true if copyright notices in files should be replaced,
#                   blank otherwise
func_import ()
{
  # Get the cached settings.
  # In 'import' mode, we read them only for the purpose of knowing the old
  # installed file list, and don't use them as defaults.
  cached_local_gnulib_path=
  cached_specified_modules=
  cached_incobsolete=
  cached_inc_cxx_tests=
  cached_inc_longrunning_tests=
  cached_inc_privileged_tests=
  cached_inc_unportable_tests=
  cached_inc_all_tests=
  cached_avoidlist=
  cached_sourcebase=
  cached_m4base=
  cached_pobase=
  cached_docbase=
  cached_testsbase=
  cached_inctests=
  cached_libname=
  cached_lgpl=
  cached_makefile_name=
  cached_cond_dependencies=
  cached_libtool=
  cached_macro_prefix=
  cached_po_domain=
  cached_witness_c_macro=
  cached_vc_files=
  cached_files=
  if test -f "$destdir"/$m4base/gnulib-cache.m4; then
    cached_libtool=false
    my_sed_traces='
      s,#.*$,,
      s,^dnl .*$,,
      s, dnl .*$,,
      /gl_LOCAL_DIR(/ {
        s,^.*gl_LOCAL_DIR([[ ]*\([^]"$`\\)]*\).*$,cached_local_gnulib_path="\1",p
      }
      /gl_MODULES(/ {
        ta
        :a
          s/)/)/
          tb
          N
          ba
        :b
        s,^.*gl_MODULES([[ ]*\([^]"$`\\)]*\).*$,cached_specified_modules="\1",p
      }
      /gl_WITH_OBSOLETE/ {
        s,^.*$,cached_incobsolete=true,p
      }
      /gl_WITH_CXX_TESTS/ {
        s,^.*$,cached_inc_cxx_tests=true,p
      }
      /gl_WITH_LONGRUNNING_TESTS/ {
        s,^.*$,cached_inc_longrunning_tests=true,p
      }
      /gl_WITH_PRIVILEGED_TESTS/ {
        s,^.*$,cached_inc_privileged_tests=true,p
      }
      /gl_WITH_UNPORTABLE_TESTS/ {
        s,^.*$,cached_inc_unportable_tests=true,p
      }
      /gl_WITH_ALL_TESTS/ {
        s,^.*$,cached_inc_all_tests=true,p
      }
      /gl_AVOID(/ {
        s,^.*gl_AVOID([[ ]*\([^]"$`\\)]*\).*$,cached_avoidlist="\1",p
      }
      /gl_SOURCE_BASE(/ {
        s,^.*gl_SOURCE_BASE([[ ]*\([^]"$`\\)]*\).*$,cached_sourcebase="\1",p
      }
      /gl_M4_BASE(/ {
        s,^.*gl_M4_BASE([[ ]*\([^]"$`\\)]*\).*$,cached_m4base="\1",p
      }
      /gl_PO_BASE(/ {
        s,^.*gl_PO_BASE([[ ]*\([^]"$`\\)]*\).*$,cached_pobase="\1",p
      }
      /gl_DOC_BASE(/ {
        s,^.*gl_DOC_BASE([[ ]*\([^]"$`\\)]*\).*$,cached_docbase="\1",p
      }
      /gl_TESTS_BASE(/ {
        s,^.*gl_TESTS_BASE([[ ]*\([^]"$`\\)]*\).*$,cached_testsbase="\1",p
      }
      /gl_WITH_TESTS/ {
        s,^.*$,cached_inctests=true,p
      }
      /gl_LIB(/ {
        s,^.*gl_LIB([[ ]*\([^]"$`\\)]*\).*$,cached_libname="\1",p
      }
      /gl_LGPL(/ {
        s,^.*gl_LGPL([[ ]*\([^]"$`\\)]*\).*$,cached_lgpl="\1",p
      }
      /gl_LGPL/ {
        s,^.*$,cached_lgpl=yes,p
      }
      /gl_MAKEFILE_NAME(/ {
        s,^.*gl_MAKEFILE_NAME([[ ]*\([^]"$`\\)]*\).*$,cached_makefile_name="\1",p
      }
      /gl_CONDITIONAL_DEPENDENCIES/ {
        s,^.*$,cached_cond_dependencies=true,p
      }
      /gl_LIBTOOL/ {
        s,^.*$,cached_libtool=true,p
      }
      /gl_MACRO_PREFIX(/ {
        s,^.*gl_MACRO_PREFIX([[ ]*\([^]"$`\\)]*\).*$,cached_macro_prefix="\1",p
      }
      /gl_PO_DOMAIN(/ {
        s,^.*gl_PO_DOMAIN([[ ]*\([^]"$`\\)]*\).*$,cached_po_domain="\1",p
      }
      /gl_WITNESS_C_MACRO(/ {
        s,^.*gl_WITNESS_C_MACRO([[ ]*\([^]"$`\\)]*\).*$,cached_witness_c_macro="\1",p
      }
      /gl_VC_FILES(/ {
        s,^.*gl_VC_FILES([[ ]*\([^]"$`\\)]*\).*$,cached_vc_files="\1",p
      }'
    eval `sed -n -e "$my_sed_traces" < "$destdir"/$m4base/gnulib-cache.m4`
    if test -f "$destdir"/$m4base/gnulib-comp.m4; then
      my_sed_traces='
        s,#.*$,,
        s,^dnl .*$,,
        s, dnl .*$,,
        /AC_DEFUN(\['"${cached_macro_prefix}"'_FILE_LIST\], \[/ {
          s,^.*$,cached_files=",p
          n
          ta
          :a
          s,^\]).*$,",
          tb
          s,["$`\\],,g
          p
          n
          ba
          :b
          p
        }'
      eval `sed -n -e "$my_sed_traces" < "$destdir"/$m4base/gnulib-comp.m4`
    fi
  fi

  if test "$mode" = import; then
    # In 'import' mode, the new set of specified modules overrides the cached
    # set of modules. Ignore the cached settings.
    specified_modules="$1"
  else
    # Merge the cached settings with the specified ones.
    # The m4base must be the same as expected from the pathname.
    if test -n "$cached_m4base" && test "$cached_m4base" != "$m4base"; then
      func_fatal_error "$m4base/gnulib-cache.m4 is expected to contain gl_M4_BASE([$m4base])"
    fi
    # The local_gnulib_path defaults to the cached one. Recall that the cached one
    # is relative to $destdir, whereas the one we use is relative to . or absolute.
    if test -z "$local_gnulib_path"; then
      func_reconstruct_cached_local_gnulib_path
    fi
    case $mode in
      add-import)
        # Append the cached and the specified module names. So that
        # "gnulib-tool --add-import foo" means to add the module foo.
        specified_modules="$cached_specified_modules $1"
        ;;
      remove-import)
        # Take the cached module names, minus the specified module names.
        specified_modules=
        if $have_associative; then
          # Use an associative array, for O(N) worst-case run time.
          declare -A to_remove
          for m in $1; do
            eval 'to_remove[$m]=yes'
          done
          for module in $cached_specified_modules; do
            if eval 'test -z "${to_remove[$module]}"'; then
              func_append specified_modules "$module "
            fi
          done
        else
          # This loop has O(N**2) worst-case run time.
          for module in $cached_specified_modules; do
            to_remove=
            for m in $1; do
              if test "$m" = "$module"; then
                to_remove=yes
                break
              fi
            done
            if test -z "$to_remove"; then
              func_append specified_modules "$module "
            fi
          done
        fi
        ;;
      update)
        # Take the cached module names. There are no specified module names.
        specified_modules="$cached_specified_modules"
        ;;
    esac
    # Included obsolete modules among the dependencies if specified either way.
    if test -z "$incobsolete"; then
      incobsolete="$cached_incobsolete"
    fi
    # Included special kinds of tests modules among the dependencies if specified
    # either way.
    if test -z "$inc_cxx_tests"; then
      inc_cxx_tests="$cached_inc_cxx_tests"
    fi
    if test -z "$inc_longrunning_tests"; then
      inc_longrunning_tests="$cached_inc_longrunning_tests"
    fi
    if test -z "$inc_privileged_tests"; then
      inc_privileged_tests="$cached_inc_privileged_tests"
    fi
    if test -z "$inc_unportable_tests"; then
      inc_unportable_tests="$cached_inc_unportable_tests"
    fi
    if test -z "$inc_all_tests"; then
      inc_all_tests="$cached_inc_all_tests"
    fi
    # Append the cached and the specified avoidlist. This is probably better
    # than dropping the cached one when --avoid is specified at least once.
    avoidlist=`for m in $cached_avoidlist $avoidlist; do echo $m; done | LC_ALL=C sort -u`
    avoidlist=`echo $avoidlist`

    # The sourcebase defaults to the cached one.
    if test -z "$sourcebase"; then
      sourcebase="$cached_sourcebase"
      if test -z "$sourcebase"; then
        func_fatal_error "missing --source-base option"
      fi
    fi
    # The pobase defaults to the cached one.
    if test -z "$pobase"; then
      pobase="$cached_pobase"
    fi
    # The docbase defaults to the cached one.
    if test -z "$docbase"; then
      docbase="$cached_docbase"
      if test -z "$docbase"; then
        func_fatal_error "missing --doc-base option. --doc-base has been introduced on 2006-07-11; if your last invocation of 'gnulib-tool --import' is before that date, you need to run 'gnulib-tool --import' once, with a --doc-base option."
      fi
    fi
    # The testsbase defaults to the cached one.
    if test -z "$testsbase"; then
      testsbase="$cached_testsbase"
      if test -z "$testsbase"; then
        func_fatal_error "missing --tests-base option"
      fi
    fi
    # Require the tests if specified either way.
    if ! $inctests; then
      inctests="$cached_inctests"
      if test -z "$inctests"; then
        inctests=false
      fi
    fi
    # The libname defaults to the cached one.
    if test -z "$supplied_libname"; then
      libname="$cached_libname"
      if test -z "$libname"; then
        func_fatal_error "missing --lib option"
      fi
    fi
    # Require LGPL if specified either way.
    if test -z "$lgpl"; then
      lgpl="$cached_lgpl"
    fi
    # The makefile_name defaults to the cached one.
    if test -z "$makefile_name"; then
      makefile_name="$cached_makefile_name"
    fi
    # Use conditional dependencies if specified either way.
    if test -z "$cond_dependencies"; then
      cond_dependencies="$cached_cond_dependencies"
    fi
    # Use libtool if specified either way, or if guessed.
    if test -z "$libtool"; then
      if test -n "$cached_m4base"; then
        libtool="$cached_libtool"
      else
        libtool="$guessed_libtool"
      fi
    fi
    # The macro_prefix defaults to the cached one.
    if test -z "$macro_prefix"; then
      macro_prefix="$cached_macro_prefix"
      if test -z "$macro_prefix"; then
        func_fatal_error "missing --macro-prefix option"
      fi
    fi
    # The po_domain defaults to the cached one.
    if test -z "$po_domain"; then
      po_domain="$cached_po_domain"
    fi
    # The witness_c_macro defaults to the cached one.
    if test -z "$witness_c_macro"; then
      witness_c_macro="$cached_witness_c_macro"
    fi
    # The vc_files defaults to the cached one.
    if test -z "$vc_files"; then
      vc_files="$cached_vc_files"
    fi
    # Ensure constraints.
    if test "$cond_dependencies" = true && $inctests; then
      echo "gnulib-tool: option --conditional-dependencies is not supported with --with-tests" 1>&2
      func_exit 1
    fi
  fi
  # --without-*-tests options are not supported here.
  excl_cxx_tests=
  excl_longrunning_tests=
  excl_privileged_tests=
  excl_unportable_tests=

  # Canonicalize the list of specified modules.
  specified_modules=`for m in $specified_modules; do echo $m; done | LC_ALL=C sort -u`

  # Include all kinds of tests modules if --with-all-tests was specified.
  inc_all_direct_tests="$inc_all_tests"
  inc_all_indirect_tests="$inc_all_tests"

  # Determine final module list.
  modules="$specified_modules"
  func_modules_transitive_closure
  if test $verbose -ge 0; then
    func_show_module_list
  fi
  final_modules="$modules"

  # Determine main module list and tests-related module list separately.
  func_modules_transitive_closure_separately

  # Determine whether a $testsbase/libtests.a is needed.
  func_determine_use_libtests

  # Add the dummy module to the main module list or to the tests-related module
  # list if needed.
  func_modules_add_dummy_separately

  # If --lgpl, verify that the licenses of modules are compatible.
  if test -n "$lgpl"; then
    license_incompatibilities=
    for module in $main_modules; do
      license=`func_get_license $module`
      case $license in
        'GPLed build tool') ;;
        'public domain' | 'unlimited' | 'unmodifiable license text') ;;
        *)
          case "$lgpl" in
            yes | 3)
              case $license in
                LGPLv2+ | 'LGPLv3+ or GPLv2' | LGPLv3+ | LGPL) ;;
                *) func_append license_incompatibilities "$module $license$nl" ;;
              esac
              ;;
            3orGPLv2)
              case $license in
                LGPLv2+ | 'LGPLv3+ or GPLv2') ;;
                *) func_append license_incompatibilities "$module $license$nl" ;;
              esac
              ;;
            2)
              case $license in
                LGPLv2+) ;;
                *) func_append license_incompatibilities "$module $license$nl" ;;
              esac
              ;;
            *) func_fatal_error "invalid value lgpl=$lgpl" ;;
          esac
          ;;
      esac
    done
    if test -n "$license_incompatibilities"; then
      # Format the license incompatibilities as a table.
      sed_expand_column1_width50_indent17='s,^\([^ ]*\) ,\1                                                   ,
s,^\(.................................................[^ ]*\) *,                 \1 ,'
      license_incompatibilities=`echo "$license_incompatibilities" | sed -e "$sed_expand_column1_width50_indent17"`
      func_fatal_error "incompatible license on modules:$nl$license_incompatibilities"
    fi
  fi

  # Show banner notice of every module.
  modules="$main_modules"
  func_modules_notice

  # Determine script to apply to imported library files.
  sed_transform_lib_file=
  for module in $main_modules; do
    if test $module = config-h; then
      # Assume config.h exists, and that -DHAVE_CONFIG_H is omitted.
      sed_transform_lib_file=$sed_transform_lib_file'
        s/^#ifdef[       ]*HAVE_CONFIG_H[        ]*$/#if 1/
      '
      break
    fi
  done
  sed_transform_main_lib_file="$sed_transform_lib_file"
  if test -n "$do_copyrights"; then
    if test -n "$lgpl"; then
      # Update license.
      case "$lgpl" in
        yes | 3)
          sed_transform_main_lib_file=$sed_transform_main_lib_file'
            s/GNU General/GNU Lesser General/g
            s/General Public License/Lesser General Public License/g
            s/Lesser Lesser General Public License/Lesser General Public License/g
          '
          ;;
        3orGPLv2)
          sed_transform_main_lib_file=$sed_transform_main_lib_file'
            /^ *This program is free software/i\
   This program is free software: you can redistribute it and\/or\
   modify it under the terms of either:\
\
     * the GNU Lesser General Public License as published by the Free\
       Software Foundation; either version 3 of the License, or (at your\
       option) any later version.\
\
   or\
\
     * the GNU General Public License as published by the Free\
       Software Foundation; either version 2 of the License, or (at your\
       option) any later version.\
\
   or both in parallel, as here.
            /^ *This program is free software/,/^$/d
          '
          ;;
        2)
          sed_transform_main_lib_file=$sed_transform_main_lib_file'
            s/GNU General/GNU Lesser General/g
            s/General Public License/Lesser General Public License/g
            s/Lesser Lesser General Public License/Lesser General Public License/g

            s/version [23]\([ ,]\)/version 2.1\1/g
          '
          ;;
        *) func_fatal_error "invalid value lgpl=$lgpl" ;;
      esac
    else
      # Update license.
      sed_transform_main_lib_file=$sed_transform_main_lib_file'
        s/GNU Lesser General/GNU General/g
        s/Lesser General Public License/General Public License/g

        s/GNU Library General/GNU General/g
        s/Library General Public License/General Public License/g

        s/version 2\(.1\)\{0,1\}\([ ,]\)/version 3\2/g
      '
    fi
  fi

  # Determine script to apply to auxiliary files that go into $auxdir/.
  sed_transform_build_aux_file=
  if test -n "$do_copyrights"; then
    # Update license.
    sed_transform_build_aux_file=$sed_transform_build_aux_file'
      s/GNU Lesser General/GNU General/g
      s/Lesser General Public License/General Public License/g

      s/GNU Library General/GNU General/g
      s/Library General Public License/General Public License/g

      s/version 2\(.1\)\{0,1\}\([ ,]\)/version 3\2/g
    '
  fi

  # Determine script to apply to library files that go into $testsbase/.
  sed_transform_testsrelated_lib_file="$sed_transform_lib_file"
  if test -n "$do_copyrights"; then
    # Update license.
    sed_transform_testsrelated_lib_file=$sed_transform_testsrelated_lib_file'
      s/GNU Lesser General/GNU General/g
      s/Lesser General Public License/General Public License/g

      s/GNU Library General/GNU General/g
      s/Library General Public License/General Public License/g

      s/version 2\(.1\)\{0,1\}\([ ,]\)/version 3\2/g
    '
  fi

  # Determine the final file lists.
  func_modules_to_filelist_separately

  test -n "$files" \
    || func_fatal_error "refusing to do nothing"

  # Add m4/gnulib-tool.m4 to the file list. It is not part of any module.
  new_files="$files m4/gnulib-tool.m4"
  old_files="$cached_files"
  if test -f "$destdir"/$m4base/gnulib-tool.m4; then
    func_append old_files " m4/gnulib-tool.m4"
  fi

  rewritten='%REWRITTEN%'
  sed_rewrite_old_files="\
    s,^build-aux/,$rewritten$auxdir/,
    s,^doc/,$rewritten$cached_docbase/,
    s,^lib/,$rewritten$cached_sourcebase/,
    s,^m4/,$rewritten$cached_m4base/,
    s,^tests/,$rewritten$cached_testsbase/,
    s,^tests=lib/,$rewritten$cached_testsbase/,
    s,^top/,$rewritten,
    s,^$rewritten,,"
  sed_rewrite_new_files="\
    s,^build-aux/,$rewritten$auxdir/,
    s,^doc/,$rewritten$docbase/,
    s,^lib/,$rewritten$sourcebase/,
    s,^m4/,$rewritten$m4base/,
    s,^tests/,$rewritten$testsbase/,
    s,^tests=lib/,$rewritten$testsbase/,
    s,^top/,$rewritten,
    s,^$rewritten,,"

  # Determine whether to put anything into $testsbase.
  testsfiles=`echo "$files" | sed -n -e 's,^tests/,,p' -e 's,^tests=lib/,,p'`
  if test -n "$testsfiles"; then
    gentests=true
  else
    gentests=false
  fi

  # Create directories.
  { echo "$sourcebase"
    echo "$m4base"
    if test -n "$pobase"; then
      echo "$pobase"
    fi
    docfiles=`echo "$files" | sed -n -e 's,^doc/,,p'`
    if test -n "$docfiles"; then
      echo "$docbase"
    fi
    if $gentests; then
      echo "$testsbase"
    fi
    echo "$auxdir"
    for f in $files; do echo $f; done \
      | sed -e "$sed_rewrite_new_files" \
      | sed -n -e 's,^\(.*\)/[^/]*,\1,p' \
      | LC_ALL=C sort -u
  } > "$tmp"/dirs
  { # Rearrange file descriptors. Needed because "while ... done < ..."
    # constructs are executed in a subshell e.g. by Solaris 10 /bin/sh.
    exec 5<&0 < "$tmp"/dirs
    while read d; do
      if test ! -d "$destdir/$d"; then
        if $doit; then
          echo "Creating directory $destdir/$d"
          mkdir -p "$destdir/$d" || func_fatal_error "failed"
        else
          echo "Create directory $destdir/$d"
        fi
      fi
    done
    exec 0<&5 5<&-
  }

  # Copy files or make symbolic links or hard links. Remove obsolete files.
  added_files=''
  removed_files=''
  delimiter='   '
  # Construct a table with 2 columns: rewritten-file-name original-file-name,
  # representing the files according to the last gnulib-tool invocation.
  for f in $old_files; do echo $f; done \
    | sed -e "s,^.*\$,&$delimiter&," -e "$sed_rewrite_old_files" \
    | LC_ALL=C sort \
    > "$tmp"/old-files
  # Construct a table with 2 columns: rewritten-file-name original-file-name,
  # representing the files after this gnulib-tool invocation.
  for f in $new_files; do echo $f; done \
    | sed -e "s,^.*\$,&$delimiter&," -e "$sed_rewrite_new_files" \
    | LC_ALL=C sort \
    > "$tmp"/new-files
  # First the files that are in old-files, but not in new-files:
  sed_take_first_column='s,'"$delimiter"'.*,,'
  for g in `LC_ALL=C join -t"$delimiter" -v1 "$tmp"/old-files "$tmp"/new-files | sed -e "$sed_take_first_column"`; do
    # Remove the file. Do nothing if the user already removed it.
    if test -f "$destdir/$g" || test -h "$destdir/$g"; then
      if $doit; then
        echo "Removing file $g (backup in ${g}~)"
        mv -f "$destdir/$g" "$destdir/${g}~" || func_fatal_error "failed"
      else
        echo "Remove file $g (backup in ${g}~)"
      fi
      func_append removed_files "$g$nl"
    fi
  done
  # func_add_or_update handles a file that ought to be present afterwards.
  # Uses parameters
  # - f             the original file name
  # - g             the rewritten file name
  # - already_present  nonempty if the file should already exist, empty
  #                    otherwise
  func_add_or_update ()
  {
    of="$f"
    case "$f" in
      tests=lib/*) f=`echo "$f" | sed -e 's,^tests=lib/,lib/,'` ;;
    esac
    func_dest_tmpfilename "$g"
    func_lookup_file "$f"
    cp "$lookedup_file" "$tmpfile" || func_fatal_error "failed"
    func_ensure_writable "$tmpfile"
    case "$f" in
      *.class | *.mo )
        # Don't process binary files with sed.
        ;;
      *)
        if test -n "$sed_transform_main_lib_file"; then
          case "$of" in
            lib/*)
              sed -e "$sed_transform_main_lib_file" \
                < "$lookedup_file" > "$tmpfile" || func_fatal_error "failed"
              ;;
          esac
        fi
        if test -n "$sed_transform_build_aux_file"; then
          case "$of" in
            build-aux/*)
              sed -e "$sed_transform_build_aux_file" \
                < "$lookedup_file" > "$tmpfile" || func_fatal_error "failed"
              ;;
          esac
        fi
        if test -n "$sed_transform_testsrelated_lib_file"; then
          case "$of" in
            tests=lib/*)
              sed -e "$sed_transform_testsrelated_lib_file" \
                < "$lookedup_file" > "$tmpfile" || func_fatal_error "failed"
              ;;
          esac
        fi
        ;;
    esac
    if test -f "$destdir/$g"; then
      # The file already exists.
      func_update_file
    else
      # Install the file.
      # Don't protest if the file should be there but isn't: it happens
      # frequently that developers don't put autogenerated files under version control.
      func_add_file
      func_append added_files "$g$nl"
    fi
    rm -f "$tmpfile"
  }
  # Then the files that are in new-files, but not in old-files:
  sed_take_last_column='s,^.*'"$delimiter"',,'
  already_present=
  LC_ALL=C join -t"$delimiter" -v2 "$tmp"/old-files "$tmp"/new-files \
    | sed -e "$sed_take_last_column" \
    | sed -e "s,^.*\$,&$delimiter&," -e "$sed_rewrite_new_files" > "$tmp"/added-files
  { # Rearrange file descriptors. Needed because "while ... done < ..."
    # constructs are executed in a subshell e.g. by Solaris 10 /bin/sh.
    exec 5<&0 < "$tmp"/added-files
    while read g f; do
      func_add_or_update
    done
    exec 0<&5 5<&-
  }
  # Then the files that are in new-files and in old-files:
  already_present=true
  LC_ALL=C join -t"$delimiter" "$tmp"/old-files "$tmp"/new-files \
    | sed -e "$sed_take_last_column" \
    | sed -e "s,^.*\$,&$delimiter&," -e "$sed_rewrite_new_files" > "$tmp"/kept-files
  { # Rearrange file descriptors. Needed because "while ... done < ..."
    # constructs are executed in a subshell e.g. by Solaris 10 /bin/sh.
    exec 5<&0 < "$tmp"/kept-files
    while read g f; do
      func_add_or_update
    done
    exec 0<&5 5<&-
  }

  # Command-line invocation printed in a comment in generated gnulib-cache.m4.
  actioncmd="# gnulib-tool --import"

  # Local helper.
  func_append_local_dir ()
  {
    func_append "$1" " --local-dir=$2"
  }
  func_path_foreach "$local_gnulib_path" func_append_local_dir actioncmd %dir%

  # Break the action command log into multiple lines.
  # Emacs puts some gnulib-tool log lines in its source repository, and
  # git send-email rejects patch lines longer than 998 characters.
  # Also, config.status uses awk, and the HP-UX 11.00 awk fails if a
  # line has length >= 3071; similarly, the IRIX 6.5 awk fails if a
  # line has length >= 3072.
  func_append_actionarg ()
  {
    func_append actioncmd " \\$nl#  $1"
  }
  func_append_actionarg "--lib=$libname"
  func_append_actionarg "--source-base=$sourcebase"
  func_append_actionarg "--m4-base=$m4base"
  if test -n "$pobase"; then
    func_append_actionarg "--po-base=$pobase"
  fi
  func_append_actionarg "--doc-base=$docbase"
  func_append_actionarg "--tests-base=$testsbase"
  func_append_actionarg "--aux-dir=$auxdir"
  if $inctests; then
    func_append_actionarg "--with-tests"
  fi
  if test -n "$incobsolete"; then
    func_append_actionarg "--with-obsolete"
  fi
  if test -n "$inc_cxx_tests"; then
    func_append_actionarg "--with-c++-tests"
  fi
  if test -n "$inc_longrunning_tests"; then
    func_append_actionarg "--with-longrunning-tests"
  fi
  if test -n "$inc_privileged_tests"; then
    func_append_actionarg "--with-privileged-tests"
  fi
  if test -n "$inc_unportable_tests"; then
    func_append_actionarg "--with-unportable-tests"
  fi
  if test -n "$inc_all_tests"; then
    func_append_actionarg "--with-all-tests"
  fi
  if test -n "$lgpl"; then
    if test "$lgpl" = yes; then
      func_append_actionarg "--lgpl"
    else
      func_append_actionarg "--lgpl=$lgpl"
    fi
  fi
  if $gnu_make; then
    func_append_actionarg "--gnu-make"
  fi
  if test -n "$makefile_name"; then
    func_append_actionarg "--makefile-name=$makefile_name"
  fi
  if test "$cond_dependencies" = true; then
    func_append_actionarg "--conditional-dependencies"
  else
    func_append_actionarg "--no-conditional-dependencies"
  fi
  if test "$libtool" = true; then
    func_append_actionarg "--libtool"
  else
    func_append_actionarg "--no-libtool"
  fi
  func_append_actionarg "--macro-prefix=$macro_prefix"
  if test -n "$po_domain"; then
    func_append_actionarg "--po-domain=$po_domain"
  fi
  if test -n "$witness_c_macro"; then
    func_append_actionarg "--witness-c-macro=$witness_c_macro"
  fi
  if test -n "$vc_files"; then
    if test "$vc_files" = true; then
      func_append_actionarg "--vc-files"
    else
      func_append_actionarg "--no-vc-files"
    fi
  fi
  for module in $avoidlist; do
    func_append_actionarg "--avoid=$module"
  done
  for module in $specified_modules; do
    func_append_actionarg "$module"
  done

  # Determine include_guard_prefix.
  func_compute_include_guard_prefix

  # Default the makefile name to Makefile.am.
  if test -n "$makefile_name"; then
    makefile_am=$makefile_name
  else
    makefile_am=Makefile.am
  fi

  # Create normal Makefile.ams.
  for_test=false

  # Setup list of Makefile.am edits that are to be performed afterwards.
  # Some of these edits apply to files that we will generate; others are
  # under the responsibility of the developer.
  makefile_am_edits=0
  # func_note_Makefile_am_edit dir var value [dotfirst]
  # remembers that ${dir}Makefile.am needs to be edited to that ${var} mentions
  # ${value}.
  # If ${dotfirst} is non-empty, this mention needs to be present after '.'.
  # This is a special hack for the SUBDIRS variable, cf.
  # <https://www.gnu.org/software/automake/manual/html_node/Subdirectories.html>.
  func_note_Makefile_am_edit ()
  {
    makefile_am_edits=`expr $makefile_am_edits + 1`
    eval makefile_am_edit${makefile_am_edits}_dir=\"\$1\"
    eval makefile_am_edit${makefile_am_edits}_var=\"\$2\"
    eval makefile_am_edit${makefile_am_edits}_val=\"\$3\"
    eval makefile_am_edit${makefile_am_edits}_dotfirst=\"\$4\"
  }
  if test "$makefile_am" = Makefile.am; then
    sourcebase_dir=`echo "$sourcebase" | sed -n -e 's,/[^/]*$,/,p'`
    sourcebase_base=`basename "$sourcebase"`
    func_note_Makefile_am_edit "$sourcebase_dir" SUBDIRS "$sourcebase_base"
  fi
  if test -n "$pobase"; then
    pobase_dir=`echo "$pobase" | sed -n -e 's,/[^/]*$,/,p'`
    pobase_base=`basename "$pobase"`
    func_note_Makefile_am_edit "$pobase_dir" SUBDIRS "$pobase_base"
  fi
  if $inctests; then
    if test "$makefile_am" = Makefile.am; then
      testsbase_dir=`echo "$testsbase" | sed -n -e 's,/[^/]*$,/,p'`
      testsbase_base=`basename "$testsbase"`
      func_note_Makefile_am_edit "$testsbase_dir" SUBDIRS "$testsbase_base" true
    fi
  fi
  func_note_Makefile_am_edit "" ACLOCAL_AMFLAGS "-I ${m4base}"
  {
    # Find the first parent directory of $m4base that contains or will contain
    # a Makefile.am.
    sed_last='s,^.*/\([^/][^/]*\)//*$,\1/,
s,//*$,/,'
    sed_butlast='s,[^/][^/]*//*$,,'
    dir1="${m4base}/"; dir2=""
    while test -n "$dir1" \
          && ! { test -f "${destdir}/${dir1}Makefile.am" \
                 || test "${dir1}Makefile.am" = "$sourcebase/$makefile_am" \
                 || test "./${dir1}Makefile.am" = "$sourcebase/$makefile_am" \
                 || { $gentests \
                      && { test "${dir1}Makefile.am" = "$testsbase/$makefile_am" \
                           || test "./${dir1}Makefile.am" = "$testsbase/$makefile_am"; }; }; }; do
      dir2=`echo "$dir1" | sed -e "$sed_last"`"$dir2"
      dir1=`echo "$dir1" | sed -e "$sed_butlast"`
    done
    func_note_Makefile_am_edit "$dir1" EXTRA_DIST "${dir2}gnulib-cache.m4"
  }

  # Create library makefile.
  func_dest_tmpfilename $sourcebase/$makefile_am
  destfile="$sourcebase/$makefile_am"
  modules="$main_modules"
  func_emit_lib_Makefile_am > "$tmpfile"
  if test -f "$destdir"/$sourcebase/$makefile_am; then
    if cmp -s "$destdir"/$sourcebase/$makefile_am "$tmpfile"; then
      rm -f "$tmpfile"
    else
      if $doit; then
        echo "Updating $sourcebase/$makefile_am (backup in $sourcebase/$makefile_am~)"
        mv -f "$destdir"/$sourcebase/$makefile_am "$destdir"/$sourcebase/$makefile_am~
        mv -f "$tmpfile" "$destdir"/$sourcebase/$makefile_am
      else
        echo "Update $sourcebase/$makefile_am (backup in $sourcebase/$makefile_am~)"
        rm -f "$tmpfile"
      fi
    fi
  else
    if $doit; then
      echo "Creating $sourcebase/$makefile_am"
      mv -f "$tmpfile" "$destdir"/$sourcebase/$makefile_am
    else
      echo "Create $sourcebase/$makefile_am"
      rm -f "$tmpfile"
    fi
    func_append added_files "$sourcebase/$makefile_am$nl"
  fi

  # Create po/ directory.
  if test -n "$pobase"; then
    # Create po makefile and auxiliary files.
    for file in Makefile.in.in remove-potcdate.sin; do
      func_dest_tmpfilename $pobase/$file
      func_lookup_file build-aux/po/$file
      cat "$lookedup_file" > "$tmpfile"
      if test -f "$destdir"/$pobase/$file; then
        if cmp -s "$destdir"/$pobase/$file "$tmpfile"; then
          rm -f "$tmpfile"
        else
          if $doit; then
            echo "Updating $pobase/$file (backup in $pobase/$file~)"
            mv -f "$destdir"/$pobase/$file "$destdir"/$pobase/$file~
            mv -f "$tmpfile" "$destdir"/$pobase/$file
          else
            echo "Update $pobase/$file (backup in $pobase/$file~)"
            rm -f "$tmpfile"
          fi
        fi
      else
        if $doit; then
          echo "Creating $pobase/$file"
          mv -f "$tmpfile" "$destdir"/$pobase/$file
        else
          echo "Create $pobase/$file"
          rm -f "$tmpfile"
        fi
        func_append added_files "$pobase/$file$nl"
      fi
    done
    # Create po makefile parameterization, part 1.
    func_dest_tmpfilename $pobase/Makevars
    func_emit_po_Makevars > "$tmpfile"
    if test -f "$destdir"/$pobase/Makevars; then
      if cmp -s "$destdir"/$pobase/Makevars "$tmpfile"; then
        rm -f "$tmpfile"
      else
        if $doit; then
          echo "Updating $pobase/Makevars (backup in $pobase/Makevars~)"
          mv -f "$destdir"/$pobase/Makevars "$destdir"/$pobase/Makevars~
          mv -f "$tmpfile" "$destdir"/$pobase/Makevars
        else
          echo "Update $pobase/Makevars (backup in $pobase/Makevars~)"
          rm -f "$tmpfile"
        fi
      fi
    else
      if $doit; then
        echo "Creating $pobase/Makevars"
        mv -f "$tmpfile" "$destdir"/$pobase/Makevars
      else
        echo "Create $pobase/Makevars"
        rm -f "$tmpfile"
      fi
      func_append added_files "$pobase/Makevars$nl"
    fi
    # Create po makefile parameterization, part 2.
    func_dest_tmpfilename $pobase/POTFILES.in
    func_emit_po_POTFILES_in > "$tmpfile"
    if test -f "$destdir"/$pobase/POTFILES.in; then
      if cmp -s "$destdir"/$pobase/POTFILES.in "$tmpfile"; then
        rm -f "$tmpfile"
      else
        if $doit; then
          echo "Updating $pobase/POTFILES.in (backup in $pobase/POTFILES.in~)"
          mv -f "$destdir"/$pobase/POTFILES.in "$destdir"/$pobase/POTFILES.in~
          mv -f "$tmpfile" "$destdir"/$pobase/POTFILES.in
        else
          echo "Update $pobase/POTFILES.in (backup in $pobase/POTFILES.in~)"
          rm -f "$tmpfile"
        fi
      fi
    else
      if $doit; then
        echo "Creating $pobase/POTFILES.in"
        mv -f "$tmpfile" "$destdir"/$pobase/POTFILES.in
      else
        echo "Create $pobase/POTFILES.in"
        rm -f "$tmpfile"
      fi
      func_append added_files "$pobase/POTFILES.in$nl"
    fi
    # Fetch PO files.
    TP_URL="https://translationproject.org/latest/"
    if $doit; then
      echo "Fetching gnulib PO files from $TP_URL"
      (cd "$destdir"/$pobase \
       && wget --no-verbose --mirror --level=1 -nd -A.po -P . "${TP_URL}gnulib/"
      )
    else
      echo "Fetch gnulib PO files from $TP_URL"
    fi
    # Create po/LINGUAS.
    if $doit; then
      func_dest_tmpfilename $pobase/LINGUAS
      (cd "$destdir"/$pobase \
       && { echo '# Set of available languages.'
            LC_ALL=C ls -1 *.po | sed -e 's,\.po$,,'
          }
      ) > "$tmpfile"
      if test -f "$destdir"/$pobase/LINGUAS; then
        if cmp -s "$destdir"/$pobase/LINGUAS "$tmpfile"; then
          rm -f "$tmpfile"
        else
          echo "Updating $pobase/LINGUAS (backup in $pobase/LINGUAS~)"
          mv -f "$destdir"/$pobase/LINGUAS "$destdir"/$pobase/LINGUAS~
          mv -f "$tmpfile" "$destdir"/$pobase/LINGUAS
        fi
      else
        echo "Creating $pobase/LINGUAS"
        mv -f "$tmpfile" "$destdir"/$pobase/LINGUAS
        func_append added_files "$pobase/LINGUAS$nl"
      fi
    else
      if test -f "$destdir"/$pobase/LINGUAS; then
        echo "Update $pobase/LINGUAS (backup in $pobase/LINGUAS~)"
      else
        echo "Create $pobase/LINGUAS"
      fi
    fi
  fi

  # func_count_relative_local_gnulib_path
  # gl_LOCAL_DIR requires local_gnulib_path to be set relatively to destdir
  # Input:
  # - local_gnulib_path  from --local-dir
  # - destdir           from --dir
  # Output:
  # - relative_local_dir  path to be stored into gl_LOCAL_DIR
  func_count_relative_local_gnulib_path ()
  {
    relative_local_gnulib_path=
    save_IFS="$IFS"
    IFS="$PATH_SEPARATOR"
    for local_dir in $local_gnulib_path
    do
      IFS="$save_IFS"
      # Store the local_dir relative to destdir.
      case "$local_dir" in
        "" | /*)
          relative_local_dir="$local_dir" ;;
        * )
          case "$destdir" in
            /*) relative_local_dir="$local_dir" ;;
            *)
              # destdir, local_dir are both relative.
              func_relativize "$destdir" "$local_dir"
              relative_local_dir="$reldir" ;;
          esac ;;
      esac
      func_path_append relative_local_gnulib_path "$relative_local_dir"
    done
    IFS="$save_IFS"
  }

  # Create m4/gnulib-cache.m4.
  func_dest_tmpfilename $m4base/gnulib-cache.m4
  (
    func_emit_copyright_notice
    echo "#"
    echo "# This file represents the specification of how gnulib-tool is used."
    echo "# It acts as a cache: It is written and read by gnulib-tool."
    echo "# In projects that use version control, this file is meant to be put under"
    echo "# version control, like the configure.ac and various Makefile.am files."
    echo
    echo
    echo "# Specification in the form of a command-line invocation:"
    printf '%s\n' "$actioncmd"
    echo
    echo "# Specification in the form of a few gnulib-tool.m4 macro invocations:"
    func_count_relative_local_gnulib_path
    echo "gl_LOCAL_DIR([$relative_local_gnulib_path])"
    echo "gl_MODULES(["
    echo "$specified_modules" | sed -e 's/^/  /g'
    echo "])"
    test -z "$incobsolete" || echo "gl_WITH_OBSOLETE"
    test -z "$inc_cxx_tests" || echo "gl_WITH_CXX_TESTS"
    test -z "$inc_longrunning_tests" || echo "gl_WITH_LONGRUNNING_TESTS"
    test -z "$inc_privileged_tests" || echo "gl_WITH_PRIVILEGED_TESTS"
    test -z "$inc_unportable_tests" || echo "gl_WITH_UNPORTABLE_TESTS"
    test -z "$inc_all_tests" || echo "gl_WITH_ALL_TESTS"
    echo "gl_AVOID([$avoidlist])"
    echo "gl_SOURCE_BASE([$sourcebase])"
    echo "gl_M4_BASE([$m4base])"
    echo "gl_PO_BASE([$pobase])"
    echo "gl_DOC_BASE([$docbase])"
    echo "gl_TESTS_BASE([$testsbase])"
    if $inctests; then
      echo "gl_WITH_TESTS"
    fi
    echo "gl_LIB([$libname])"
    if test -n "$lgpl"; then
      if test "$lgpl" = yes; then
        echo "gl_LGPL"
      else
        echo "gl_LGPL([$lgpl])"
      fi
    fi
    echo "gl_MAKEFILE_NAME([$makefile_name])"
    if test "$cond_dependencies" = true; then
      echo "gl_CONDITIONAL_DEPENDENCIES"
    fi
    if test "$libtool" = true; then
      echo "gl_LIBTOOL"
    fi
    echo "gl_MACRO_PREFIX([$macro_prefix])"
    echo "gl_PO_DOMAIN([$po_domain])"
    echo "gl_WITNESS_C_MACRO([$witness_c_macro])"
    if test -n "$vc_files"; then
      echo "gl_VC_FILES([$vc_files])"
    fi
  ) > "$tmpfile"
  if test -f "$destdir"/$m4base/gnulib-cache.m4; then
    if cmp -s "$destdir"/$m4base/gnulib-cache.m4 "$tmpfile"; then
      rm -f "$tmpfile"
    else
      if $doit; then
        echo "Updating $m4base/gnulib-cache.m4 (backup in $m4base/gnulib-cache.m4~)"
        mv -f "$destdir"/$m4base/gnulib-cache.m4 "$destdir"/$m4base/gnulib-cache.m4~
        mv -f "$tmpfile" "$destdir"/$m4base/gnulib-cache.m4
      else
        echo "Update $m4base/gnulib-cache.m4 (backup in $m4base/gnulib-cache.m4~)"
        if false; then
          cat "$tmpfile"
          echo
          echo "# gnulib-cache.m4 ends here"
        fi
        rm -f "$tmpfile"
      fi
    fi
  else
    if $doit; then
      echo "Creating $m4base/gnulib-cache.m4"
      mv -f "$tmpfile" "$destdir"/$m4base/gnulib-cache.m4
    else
      echo "Create $m4base/gnulib-cache.m4"
      cat "$tmpfile"
      rm -f "$tmpfile"
    fi
  fi

  # Create m4/gnulib-comp.m4.
  func_dest_tmpfilename $m4base/gnulib-comp.m4
  (
    echo "# DO NOT EDIT! GENERATED AUTOMATICALLY!"
    func_emit_copyright_notice
    echo "#"
    echo "# This file represents the compiled summary of the specification in"
    echo "# gnulib-cache.m4. It lists the computed macro invocations that need"
    echo "# to be invoked from configure.ac."
    echo "# In projects that use version control, this file can be treated like"
    echo "# other built files."
    echo
    echo
    echo "# This macro should be invoked from $configure_ac, in the section"
    echo "# \"Checks for programs\", right after AC_PROG_CC, and certainly before"
    echo "# any checks for libraries, header files, types and library functions."
    echo "AC_DEFUN([${macro_prefix}_EARLY],"
    echo "["
    echo "  m4_pattern_forbid([^gl_[A-Z]])dnl the gnulib macro namespace"
    echo "  m4_pattern_allow([^gl_ES\$])dnl a valid locale name"
    echo "  m4_pattern_allow([^gl_LIBOBJS\$])dnl a variable"
    echo "  m4_pattern_allow([^gl_LTLIBOBJS\$])dnl a variable"

    func_emit_pre_early_macros : '  ' "$final_modules"

    if ! $gnu_make && test -n "$uses_subdirs"; then
      echo "  AC_REQUIRE([AM_PROG_CC_C_O])"
    fi
    for module in $final_modules; do
      func_verify_module
      if test -n "$module"; then
        echo "# Code from module $module:"
        func_get_autoconf_early_snippet "$module"
      fi
    done \
      | sed -e '/^$/d;' -e 's/^/  /'
    echo "])"
    echo
    echo "# This macro should be invoked from $configure_ac, in the section"
    echo "# \"Check for header files, types and library functions\"."
    echo "AC_DEFUN([${macro_prefix}_INIT],"
    echo "["
    if test "$libtool" = true; then
      echo "  AM_CONDITIONAL([GL_COND_LIBTOOL], [true])"
      echo "  gl_cond_libtool=true"
    else
      echo "  AM_CONDITIONAL([GL_COND_LIBTOOL], [false])"
      echo "  gl_cond_libtool=false"
      echo "  gl_libdeps="
      echo "  gl_ltlibdeps="
    fi
    if test "$auxdir" != "build-aux"; then
      sed_replace_build_aux='
        :a
        /AC_CONFIG_FILES(.*:build-aux\/.*)/{
          s|AC_CONFIG_FILES(\(.*\):build-aux/\(.*\))|AC_CONFIG_FILES(\1:'"$auxdir"'/\2)|
          ba
        }'
    else
      sed_replace_build_aux="$sed_noop"
    fi
    echo "  gl_m4_base='$m4base'"
    func_emit_initmacro_start $macro_prefix
    echo "  gl_source_base='$sourcebase'"
    if test -n "$witness_c_macro"; then
      echo "  m4_pushdef([gl_MODULE_INDICATOR_CONDITION], [$witness_c_macro])"
    fi
    func_emit_autoconf_snippets "$main_modules" "$main_modules" func_verify_module true false true
    if test -n "$witness_c_macro"; then
      echo "  m4_popdef([gl_MODULE_INDICATOR_CONDITION])"
    fi
    echo "  # End of code from modules"
    func_emit_initmacro_end $macro_prefix
    echo "  gltests_libdeps="
    echo "  gltests_ltlibdeps="
    func_emit_initmacro_start ${macro_prefix}tests
    echo "  gl_source_base='$testsbase'"
    # Define a tests witness macro that depends on the package.
    # PACKAGE is defined by AM_INIT_AUTOMAKE, PACKAGE_TARNAME is defined by AC_INIT.
    # See <https://lists.gnu.org/r/automake/2009-05/msg00145.html>.
    echo "changequote(,)dnl"
    echo "  ${macro_prefix}tests_WITNESS=IN_\`echo \"\${PACKAGE-\$PACKAGE_TARNAME}\" | LC_ALL=C tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ | LC_ALL=C sed -e 's/[^A-Z0-9_]/_/g'\`_GNULIB_TESTS"
    echo "changequote([, ])dnl"
    echo "  AC_SUBST([${macro_prefix}tests_WITNESS])"
    echo "  gl_module_indicator_condition=\$${macro_prefix}tests_WITNESS"
    echo "  m4_pushdef([gl_MODULE_INDICATOR_CONDITION], [\$gl_module_indicator_condition])"
    func_emit_autoconf_snippets "$testsrelated_modules" "$main_modules $testsrelated_modules" func_verify_module true true true
    echo "  m4_popdef([gl_MODULE_INDICATOR_CONDITION])"
    func_emit_initmacro_end ${macro_prefix}tests
    # _LIBDEPS and _LTLIBDEPS variables are not needed if this library is
    # created using libtool, because libtool already handles the dependencies.
    if test "$libtool" != true; then
      libname_upper=`echo "$libname" | LC_ALL=C tr '[a-z]-' '[A-Z]_'`
      echo "  ${libname_upper}_LIBDEPS=\"\$gl_libdeps\""
      echo "  AC_SUBST([${libname_upper}_LIBDEPS])"
      echo "  ${libname_upper}_LTLIBDEPS=\"\$gl_ltlibdeps\""
      echo "  AC_SUBST([${libname_upper}_LTLIBDEPS])"
    fi
    if $use_libtests; then
      echo "  LIBTESTS_LIBDEPS=\"\$gltests_libdeps\""
      echo "  AC_SUBST([LIBTESTS_LIBDEPS])"
    fi
    echo "])"
    func_emit_initmacro_done $macro_prefix $sourcebase
    func_emit_initmacro_done ${macro_prefix}tests $testsbase
    echo
    echo "# This macro records the list of files which have been installed by"
    echo "# gnulib-tool and may be removed by future gnulib-tool invocations."
    echo "AC_DEFUN([${macro_prefix}_FILE_LIST], ["
    echo "$files" | sed -e 's,^,  ,'
    echo "])"
  ) > "$tmpfile"
  if test -f "$destdir"/$m4base/gnulib-comp.m4; then
    if cmp -s "$destdir"/$m4base/gnulib-comp.m4 "$tmpfile"; then
      rm -f "$tmpfile"
    else
      if $doit; then
        echo "Updating $m4base/gnulib-comp.m4 (backup in $m4base/gnulib-comp.m4~)"
        mv -f "$destdir"/$m4base/gnulib-comp.m4 "$destdir"/$m4base/gnulib-comp.m4~
        mv -f "$tmpfile" "$destdir"/$m4base/gnulib-comp.m4
      else
        echo "Update $m4base/gnulib-comp.m4 (backup in $m4base/gnulib-comp.m4~)"
        if false; then
          cat "$tmpfile"
          echo
          echo "# gnulib-comp.m4 ends here"
        fi
        rm -f "$tmpfile"
      fi
    fi
  else
    if $doit; then
      echo "Creating $m4base/gnulib-comp.m4"
      mv -f "$tmpfile" "$destdir"/$m4base/gnulib-comp.m4
    else
      echo "Create $m4base/gnulib-comp.m4"
      cat "$tmpfile"
      rm -f "$tmpfile"
    fi
  fi

  if $gentests; then
    # Create tests makefile.
    func_dest_tmpfilename $testsbase/$makefile_am
    destfile="$testsbase/$makefile_am"
    modules="$testsrelated_modules"
    func_emit_tests_Makefile_am "${macro_prefix}tests_WITNESS" > "$tmpfile"
    if test -f "$destdir"/$testsbase/$makefile_am; then
      if cmp -s "$destdir"/$testsbase/$makefile_am "$tmpfile"; then
        rm -f "$tmpfile"
      else
        if $doit; then
          echo "Updating $testsbase/$makefile_am (backup in $testsbase/$makefile_am~)"
          mv -f "$destdir"/$testsbase/$makefile_am "$destdir"/$testsbase/$makefile_am~
          mv -f "$tmpfile" "$destdir"/$testsbase/$makefile_am
        else
          echo "Update $testsbase/$makefile_am (backup in $testsbase/$makefile_am~)"
          rm -f "$tmpfile"
        fi
      fi
    else
      if $doit; then
        echo "Creating $testsbase/$makefile_am"
        mv -f "$tmpfile" "$destdir"/$testsbase/$makefile_am
      else
        echo "Create $testsbase/$makefile_am"
        rm -f "$tmpfile"
      fi
      func_append added_files "$testsbase/$makefile_am$nl"
    fi
  fi

  if test "$vc_files" != false; then
    # Update the .cvsignore and .gitignore files.
    { echo "$added_files" | sed -e '/^$/d' -e 's,\([^/]*\)$,|A|\1,'
      echo "$removed_files" | sed -e '/^$/d' -e 's,\([^/]*\)$,|R|\1,'
      # Treat gnulib-comp.m4 like an added file, even if it already existed.
      echo "$m4base/|A|gnulib-comp.m4"
    } | LC_ALL=C sort -t'|' -k1,1 > "$tmp"/fileset-changes
    { # Rearrange file descriptors. Needed because "while ... done < ..."
      # constructs are executed in a subshell e.g. by Solaris 10 /bin/sh.
      exec 5<&0 < "$tmp"/fileset-changes
      func_update_ignorelist ()
      {
        ignore="$1"
        if test "$ignore" = .gitignore; then
          # In a .gitignore file, "foo" applies to the current directory and all
          # subdirectories, whereas "/foo" applies to the current directory only.
          anchor='/'
          escaped_anchor='\/'
          doubly_escaped_anchor='\\/'
        else
          anchor=''
          escaped_anchor=''
          doubly_escaped_anchor=''
        fi
        if test -f "$destdir/$dir$ignore"; then
          if test -n "$dir_added" || test -n "$dir_removed"; then
            sed -e "s|^$anchor||" < "$destdir/$dir$ignore" | LC_ALL=C sort > "$tmp"/ignore
            (echo "$dir_added" | sed -e '/^$/d' | LC_ALL=C sort -u \
               | LC_ALL=C join -v 1 - "$tmp"/ignore > "$tmp"/ignore-added
             echo "$dir_removed" | sed -e '/^$/d' | LC_ALL=C sort -u \
               > "$tmp"/ignore-removed
            )
            if test -s "$tmp"/ignore-added || test -s "$tmp"/ignore-removed; then
              if $doit; then
                echo "Updating $destdir/$dir$ignore (backup in $destdir/$dir${ignore}~)"
                mv -f "$destdir/$dir$ignore" "$destdir/$dir$ignore"~
                { sed -e 's,/,\\/,g' -e 's,^,/^,' -e 's,$,\$/d,' < "$tmp"/ignore-removed
                  if test -n "$anchor"; then sed -e 's,/,\\/,g' -e "s,^,/^${doubly_escaped_anchor}," -e 's,$,$/d,' < "$tmp"/ignore-removed; fi
                } > "$tmp"/sed-ignore-removed
                { cat "$destdir/$dir$ignore"~
                  sed -e "s|^|$anchor|" < "$tmp"/ignore-added
                } | sed -f "$tmp"/sed-ignore-removed \
                  > "$destdir/$dir$ignore"
              else
                echo "Update $destdir/$dir$ignore (backup in $destdir/$dir${ignore}~)"
              fi
            fi
          fi
        else
          if test -n "$dir_added"; then
            if $doit; then
              echo "Creating $destdir/$dir$ignore"
              {
                if test "$ignore" = .cvsignore; then
                  echo ".deps"
                  # Automake generates Makefile rules that create .dirstamp files.
                  echo ".dirstamp"
                fi
                echo "$dir_added" | sed -e '/^$/d' -e "s|^|$anchor|" | LC_ALL=C sort -u
              } > "$destdir/$dir$ignore"
            else
              echo "Create $destdir/$dir$ignore"
            fi
          fi
        fi
      }
      func_done_dir ()
      {
        dir="$1"
        dir_added="$2"
        dir_removed="$3"
        if test -d "$destdir/CVS" || test -d "$destdir/${dir}CVS" || test -f "$destdir/${dir}.cvsignore"; then
          func_update_ignorelist .cvsignore
        fi
        if test -d "$destdir/.git" || test -f "$destdir/${dir}.gitignore"; then
          func_update_ignorelist .gitignore
        fi
      }
      last_dir=
      last_dir_added=
      last_dir_removed=
      while read line; do
        # Why not ''read next_dir op file'' ? Because the dir column can be empty.
        next_dir=`echo "$line" | sed -e 's,|.*,,'`
        op=`echo "$line" | sed -e 's,^[^|]*|\([^|]*\)|.*$,\1,'`
        file=`echo "$line" | sed -e 's,^[^|]*|[^|]*|,,'`
        if test "$next_dir" != "$last_dir"; then
          func_done_dir "$last_dir" "$last_dir_added" "$last_dir_removed"
          last_dir="$next_dir"
          last_dir_added=
          last_dir_removed=
        fi
        case $op in
          A) func_append last_dir_added "$file$nl";;
          R) func_append last_dir_removed "$file$nl";;
        esac
      done
      func_done_dir "$last_dir" "$last_dir_added" "$last_dir_removed"
      exec 0<&5 5<&-
    }
  fi

  echo "Finished."
  echo
  echo "You may need to add #include directives for the following .h files."
  # Intersect $specified_modules and $main_modules
  # (since $specified_modules is not necessarily of subset of $main_modules
  # - some may have been skipped through --avoid, and since the elements of
  # $main_modules but not in $specified_modules can go away without explicit
  # notice - through changes in the module dependencies).
  echo "$specified_modules" > "$tmp"/modules1 # a sorted list, one module per line
  echo "$main_modules" > "$tmp"/modules2 # also a sorted list, one module per line
  # First the #include <...> directives without #ifs, sorted for convenience,
  # then the #include "..." directives without #ifs, sorted for convenience,
  # then the #include directives that are surrounded by #ifs. Not sorted.
  for module in `LC_ALL=C join "$tmp"/modules1 "$tmp"/modules2`; do
    include_directive=`func_get_include_directive "$module"`
    case "$nl$include_directive" in
      *"$nl#if"*)
        echo "$include_directive" 1>&5
        ;;
      *)
        echo "$include_directive" | grep -v 'include "' 1>&6
        echo "$include_directive" | grep 'include "' 1>&7
        ;;
    esac
  done 5> "$tmp"/include-if 6> "$tmp"/include-angles 7> "$tmp"/include-quotes
  (
   LC_ALL=C sort -u "$tmp"/include-angles
   LC_ALL=C sort -u "$tmp"/include-quotes
   cat "$tmp"/include-if
  ) | sed -e '/^$/d' -e 's/^/  /'
  rm -f "$tmp"/include-angles "$tmp"/include-quotes "$tmp"/include-if

  for module in $main_modules; do
    func_get_link_directive "$module"
  done \
    | LC_ALL=C sort -u | sed -e '/^$/d' -e 's/^/  /' > "$tmp"/link
  if test `wc -l < "$tmp"/link` != 0; then
    echo
    echo "You may need to use the following Makefile variables when linking."
    echo "Use them in <program>_LDADD when linking a program, or"
    echo "in <library>_a_LDFLAGS or <library>_la_LDFLAGS when linking a library."
    cat "$tmp"/link
  fi
  rm -f "$tmp"/link

  echo
  echo "Don't forget to"
  if test "$makefile_am" = Makefile.am; then
    echo "  - add \"$sourcebase/Makefile\" to AC_CONFIG_FILES in $configure_ac,"
  else
    echo "  - \"include $makefile_name\" from within \"$sourcebase/Makefile.am\","
  fi
  if test -n "$pobase"; then
    echo "  - add \"$pobase/Makefile.in\" to AC_CONFIG_FILES in $configure_ac,"
  fi
  if $gentests; then
    if test "$makefile_am" = Makefile.am; then
      echo "  - add \"$testsbase/Makefile\" to AC_CONFIG_FILES in $configure_ac,"
    else
      echo "  - \"include $makefile_name\" from within \"$testsbase/Makefile.am\","
    fi
  fi
  edit=0
  while test $edit != $makefile_am_edits; do
    edit=`expr $edit + 1`
    eval dir=\"\$makefile_am_edit${edit}_dir\"
    eval var=\"\$makefile_am_edit${edit}_var\"
    eval val=\"\$makefile_am_edit${edit}_val\"
    if test -n "$var"; then
      echo "  - mention \"${val}\" in ${var} in ${dir}Makefile.am,"
    fi
  done
  if grep '^ *AC_PROG_CC_STDC' "$configure_ac" > /dev/null; then
    position_early_after=AC_PROG_CC_STDC
  else
    if grep '^ *AC_PROG_CC_C99' "$configure_ac" > /dev/null; then
      position_early_after=AC_PROG_CC_C99
    else
      position_early_after=AC_PROG_CC
    fi
  fi
  echo "  - invoke ${macro_prefix}_EARLY in $configure_ac, right after $position_early_after,"
  echo "  - invoke ${macro_prefix}_INIT in $configure_ac."
}

# func_create_testdir testdir modules
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - auxdir          directory relative to destdir where to place build aux files
# - inctests        true if tests should be included, false otherwise
# - incobsolete     true if obsolete modules among dependencies should be
#                   included, blank otherwise
# - excl_cxx_tests   true if C++ interoperability tests should be excluded,
#                    blank otherwise
# - excl_longrunning_tests  true if long-runnings tests should be excluded,
#                           blank otherwise
# - excl_privileged_tests  true if tests that require root privileges should be
#                          excluded, blank otherwise
# - excl_unportable_tests  true if tests that fail on some platforms should be
#                          excluded, blank otherwise
# - single_configure  true if a single configure file should be generated,
#                     false for a separate configure file for the tests
# - avoidlist       list of modules to avoid
# - cond_dependencies  true if --conditional-dependencies was given, false if
#                      --no-conditional-dependencies was given, blank otherwise
# - libtool         true if --libtool was given, false if --no-libtool was
#                   given, blank otherwise
# - copymode        copy mode for files in general
# - lcopymode       copy mode for files from local_gnulib_path
func_create_testdir ()
{
  testdir="$1"
  modules="$2"
  if test -z "$modules"; then
    # All modules together.
    # Except config-h, which breaks all modules which use HAVE_CONFIG_H.
    # Except non-recursive-gnulib-prefix-hack, which represents a nonstandard
    # way of using Automake.
    # Except timevar, which lacks the required file timevar.def.
    # Except ftruncate, mountlist, which abort the configuration on mingw. FIXME.
    # Except lib-ignore, which leads to link errors when Sun C++ is used. FIXME.
    modules=`func_all_modules`
    modules=`for m in $modules; do case $m in config-h | non-recursive-gnulib-prefix-hack | timevar | ftruncate | mountlist | lib-ignore) ;; *) echo $m;; esac; done`
  fi
  specified_modules="$modules"

  # Canonicalize the list of specified modules.
  specified_modules=`for m in $specified_modules; do echo $m; done | LC_ALL=C sort -u`

  # Test modules which invoke AC_CONFIG_FILES cannot be used with
  # --with-tests --single-configure. Avoid them.
  if $inctests && $single_configure; then
    avoidlist="$avoidlist havelib-tests"
  fi

  # Unlike in func_import, here we want to include all kinds of tests for the
  # directly specified modules, but not for dependencies.
  inc_all_direct_tests=true
  inc_all_indirect_tests="$inc_all_tests"

  # Check that the license of every module is consistent with the license of
  # its dependencies.
  saved_inctests="$inctests"
  # When computing transitive closures, don't consider $module to depend on
  # $module-tests. Need this because tests are implicitly GPL and may depend
  # on GPL modules - therefore we don't want a warning in this case.
  inctests=false
  for requested_module in $specified_modules; do
    requested_license=`func_get_license "$requested_module"`
    if test "$requested_license" != GPL; then
      # Here we use func_modules_transitive_closure, not just
      # func_get_dependencies, so that we also detect weird situations like
      # an LGPL module which depends on a GPLed build tool module which depends
      # on a GPL module.
      modules="$requested_module"
      func_modules_transitive_closure
      for module in $modules; do
        license=`func_get_license "$module"`
        case "$license" in
          'GPLed build tool') ;;
          'public domain' | 'unlimited' | 'unmodifiable license text') ;;
          *)
            case "$requested_license" in
              GPLv3+ | GPL)
                case "$license" in
                  LGPLv2+ | 'LGPLv3+ or GPLv2' | LGPLv3+ | LGPL | GPLv2+ | GPLv3+ | GPL) ;;
                  *) func_warning "module $requested_module depends on a module with an incompatible license: $module" ;;
                esac
                ;;
              GPLv2+)
                case "$license" in
                  LGPLv2+ | 'LGPLv3+ or GPLv2' |                  GPLv2+) ;;
                  *) func_warning "module $requested_module depends on a module with an incompatible license: $module" ;;
                esac
                ;;
              LGPLv3+ | LGPL)
                case "$license" in
                  LGPLv2+ | 'LGPLv3+ or GPLv2' | LGPLv3+ | LGPL) ;;
                  *) func_warning "module $requested_module depends on a module with an incompatible license: $module" ;;
                esac
                ;;
              'LGPLv3+ or GPLv2')
                case "$license" in
                  LGPLv2+ | 'LGPLv3+ or GPLv2') ;;
                  *) func_warning "module $requested_module depends on a module with an incompatible license: $module" ;;
                esac
                ;;
              LGPLv2+)
                case "$license" in
                  LGPLv2+) ;;
                  *) func_warning "module $requested_module depends on a module with an incompatible license: $module" ;;
                esac
                ;;
            esac
            ;;
        esac
      done
    fi
  done
  inctests="$saved_inctests"

  # Subdirectory names.
  sourcebase=gllib
  m4base=glm4
  pobase=
  docbase=gldoc
  testsbase=gltests
  macro_prefix=gl
  po_domain=
  witness_c_macro=
  vc_files=

  # Determine final module list.
  modules="$specified_modules"
  func_modules_transitive_closure
  if test $verbose -ge 0; then
    func_show_module_list
  fi
  final_modules="$modules"

  if $single_configure; then
    # Determine main module list and tests-related module list separately.
    func_modules_transitive_closure_separately
  fi

  if $single_configure; then
    # Determine whether a $testsbase/libtests.a is needed.
    func_determine_use_libtests
  fi

  # Add the dummy module if needed.
  if $single_configure; then
    func_modules_add_dummy_separately
  else
    func_modules_add_dummy
  fi

  # Note:
  # If $single_configure, we use the module lists $main_modules and
  # $testsrelated_modules; $modules is merely a temporary variable.
  # Whereas if ! $single_configure, the module list is $modules.

  # Show banner notice of every module.
  if $single_configure; then
    modules="$main_modules"
    func_modules_notice
  else
    func_modules_notice
  fi

  # Determine final file list.
  if $single_configure; then
    func_modules_to_filelist_separately
  else
    func_modules_to_filelist
    if test $verbose -ge 0; then
      echo "File list:"
      echo "$files" | sed -e 's/^/  /'
    fi
  fi
  # Add files for which the copy in gnulib is newer than the one that
  # "automake --add-missing --copy" would provide.
  files="$files build-aux/config.guess"
  files="$files build-aux/config.sub"
  files=`for f in $files; do echo $f; done | LC_ALL=C sort -u`

  rewritten='%REWRITTEN%'
  sed_rewrite_files="\
    s,^build-aux/,$rewritten$auxdir/,
    s,^doc/,$rewritten$docbase/,
    s,^lib/,$rewritten$sourcebase/,
    s,^m4/,$rewritten$m4base/,
    s,^tests/,$rewritten$testsbase/,
    s,^tests=lib/,$rewritten$testsbase/,
    s,^top/,$rewritten,
    s,^$rewritten,,"

  # Create directories.
  for f in $files; do echo $f; done \
    | sed -e "$sed_rewrite_files" \
    | sed -n -e 's,^\(.*\)/[^/]*,\1,p' \
    | LC_ALL=C sort -u \
    > "$tmp"/dirs
  { # Rearrange file descriptors. Needed because "while ... done < ..."
    # constructs are executed in a subshell e.g. by Solaris 10 /bin/sh.
    exec 5<&0 < "$tmp"/dirs
    while read d; do
      mkdir -p "$testdir/$d"
    done
    exec 0<&5 5<&-
  }

  # Copy files or make symbolic links or hard links.
  delimiter='   '
  for f in $files; do echo $f; done \
    | sed -e "s,^.*\$,&$delimiter&," -e "$sed_rewrite_files" \
    | LC_ALL=C sort \
    > "$tmp"/files
  { # Rearrange file descriptors. Needed because "while ... done < ..."
    # constructs are executed in a subshell e.g. by Solaris 10 /bin/sh.
    exec 5<&0 < "$tmp"/files
    while read g f; do
      case "$f" in
        tests=lib/*) f=`echo "$f" | sed -e 's,^tests=lib/,lib/,'` ;;
      esac
      func_lookup_file "$f"
      if test -n "$lookedup_tmp"; then
        cp -p "$lookedup_file" "$testdir/$g"
        func_ensure_writable "$testdir/$g"
      else
        func_should_link
        if test "$copyaction" = symlink; then
          func_symlink "$lookedup_file" "$testdir/$g"
        else
          if test "$copyaction" = hardlink; then
            func_hardlink "$lookedup_file" "$testdir/$g"
          else
            cp -p "$lookedup_file" "$testdir/$g"
            func_ensure_writable "$testdir/$g"
          fi
        fi
      fi
    done
    exec 0<&5 5<&-
  }

  # Determine include_guard_prefix.
  func_compute_include_guard_prefix

  # Create Makefile.ams that are for testing.
  for_test=true

  # No special edits are needed.
  makefile_am_edits=0

  # Create $sourcebase/Makefile.am.
  mkdir -p "$testdir/$sourcebase"
  destfile="$sourcebase/Makefile.am"
  if $single_configure; then
    modules="$main_modules"
  fi
  func_emit_lib_Makefile_am > "$testdir/$sourcebase/Makefile.am"
  any_uses_subdirs="$uses_subdirs"

  # Create $m4base/Makefile.am.
  mkdir -p "$testdir/$m4base"
  (echo "## Process this file with automake to produce Makefile.in."
   echo
   echo "EXTRA_DIST ="
   for f in $files; do
     case "$f" in
       m4/* )
         echo "EXTRA_DIST += "`echo "$f" | sed -e 's,^m4/,,'` ;;
     esac
   done
  ) > "$testdir/$m4base/Makefile.am"

  subdirs="$sourcebase $m4base"
  subdirs_with_configure_ac=""

  if false && test -f "$testdir"/$m4base/gettext.m4; then
    # Avoid stupid error message from automake:
    # "AM_GNU_GETTEXT used but `po' not in SUBDIRS"
    mkdir -p "$testdir/po"
    (echo "## Process this file with automake to produce Makefile.in."
    ) > "$testdir/po/Makefile.am"
    func_append subdirs " po"
  fi

  if $inctests; then
    test -d "$testdir/$testsbase" || mkdir "$testdir/$testsbase"
    if $single_configure; then
      # Create $testsbase/Makefile.am.
      destfile="$testsbase/Makefile.am"
      modules="$testsrelated_modules"
      func_emit_tests_Makefile_am "${macro_prefix}tests_WITNESS" > "$testdir/$testsbase/Makefile.am"
    else
      # Viewed from the $testsbase subdirectory, $auxdir is different.
      saved_auxdir="$auxdir"
      auxdir=`echo "$testsbase/" | sed -e 's%[^/][^/]*//*%../%g'`"$auxdir"
      # Create $testsbase/Makefile.am.
      use_libtests=false
      destfile="$testsbase/Makefile.am"
      func_emit_tests_Makefile_am "" > "$testdir/$testsbase/Makefile.am"
      any_uses_subdirs="$any_uses_subdirs$uses_subdirs"
      # Create $testsbase/configure.ac.
      (echo "# Process this file with autoconf to produce a configure script."
       echo "AC_INIT([dummy], [0])"
       echo "AC_CONFIG_AUX_DIR([$auxdir])"
       echo "AM_INIT_AUTOMAKE"
       echo
       echo "AC_CONFIG_HEADERS([config.h])"
       echo
       echo "AC_PROG_CC"
       echo "AC_PROG_INSTALL"
       echo "AC_PROG_MAKE_SET"

       func_emit_pre_early_macros false '' "$modules"

       if test -n "$uses_subdirs"; then
         echo "AM_PROG_CC_C_O"
         echo
       fi
       for module in $modules; do
         func_verify_module
         if test -n "$module"; then
           case $module in
             gnumakefile | maintainer-makefile)
               # These modules are meant to be used only in the top-level directory.
               ;;
             *)
               func_get_autoconf_early_snippet "$module"
               ;;
           esac
         fi
       done \
         | sed -e '/^$/d;' -e 's/AC_REQUIRE(\[\([^()]*\)\])/\1/'
       if test "$libtool" = true; then
         echo "LT_INIT([win32-dll])"
         echo "LT_LANG([C++])"
         echo "AM_CONDITIONAL([GL_COND_LIBTOOL], [true])"
         echo "gl_cond_libtool=true"
       else
         echo "AM_CONDITIONAL([GL_COND_LIBTOOL], [false])"
         echo "gl_cond_libtool=false"
         echo "gl_libdeps="
         echo "gl_ltlibdeps="
       fi
       # Wrap the set of autoconf snippets into an autoconf macro that is then
       # invoked. This is needed because autoconf does not support AC_REQUIRE
       # at the top level:
       #   error: AC_REQUIRE(gt_CSHARPCOMP): cannot be used outside of an AC_DEFUN'd macro
       # but we want the AC_REQUIRE to have its normal meaning (provide one
       # expansion of the required macro before the current point, and only one
       # expansion total).
       echo "AC_DEFUN([gl_INIT], ["
       sed_replace_build_aux='
         :a
         /AC_CONFIG_FILES(.*:build-aux\/.*)/{
           s|AC_CONFIG_FILES(\(.*\):build-aux/\(.*\))|AC_CONFIG_FILES(\1:'"$auxdir"'/\2)|
           ba
         }'
       echo "gl_m4_base='../$m4base'"
       func_emit_initmacro_start $macro_prefix
       # We don't have explicit ordering constraints between the various
       # autoconf snippets. It's cleanest to put those of the library before
       # those of the tests.
       echo "gl_source_base='../$sourcebase'"
       func_emit_autoconf_snippets "$modules" "$modules" func_verify_nontests_module false false false
       echo "gl_source_base='.'"
       func_emit_autoconf_snippets "$modules" "$modules" func_verify_tests_module false false false
       func_emit_initmacro_end $macro_prefix
       # _LIBDEPS and _LTLIBDEPS variables are not needed if this library is
       # created using libtool, because libtool already handles the dependencies.
       if test "$libtool" != true; then
         libname_upper=`echo "$libname" | LC_ALL=C tr '[a-z]-' '[A-Z]_'`
         echo "  ${libname_upper}_LIBDEPS=\"\$gl_libdeps\""
         echo "  AC_SUBST([${libname_upper}_LIBDEPS])"
         echo "  ${libname_upper}_LTLIBDEPS=\"\$gl_ltlibdeps\""
         echo "  AC_SUBST([${libname_upper}_LTLIBDEPS])"
       fi
       echo "])"
       func_emit_initmacro_done $macro_prefix $sourcebase # FIXME use $sourcebase or $testsbase?
       echo
       echo "gl_INIT"
       echo
       # Usually $testsbase/config.h will be a superset of config.h. Verify this
       # by "merging" config.h into $testsbase/config.h; look out for gcc warnings.
       echo "AH_TOP([#include \"../config.h\"])"
       echo
       echo "AC_CONFIG_FILES([Makefile])"
       echo "AC_OUTPUT"
      ) > "$testdir/$testsbase/configure.ac"
      auxdir="$saved_auxdir"
      subdirs_with_configure_ac="$subdirs_with_configure_ac $testsbase"
    fi
    func_append subdirs " $testsbase"
  fi

  # Create Makefile.am.
  (echo "## Process this file with automake to produce Makefile.in."
   echo
   echo "AUTOMAKE_OPTIONS = 1.11 foreign"
   echo
   echo "SUBDIRS = $subdirs"
   echo
   echo "ACLOCAL_AMFLAGS = -I $m4base"
  ) > "$testdir/Makefile.am"

  # Create configure.ac.
  (echo "# Process this file with autoconf to produce a configure script."
   echo "AC_INIT([dummy], [0])"
   if test "$auxdir" != "."; then
     echo "AC_CONFIG_AUX_DIR([$auxdir])"
   fi
   echo "AM_INIT_AUTOMAKE"
   echo
   echo "AC_CONFIG_HEADERS([config.h])"
   echo
   echo "AC_PROG_CC"
   echo "AC_PROG_INSTALL"
   echo "AC_PROG_MAKE_SET"
   echo
   echo "# For autobuild."
   echo "AC_CANONICAL_BUILD"
   echo "AC_CANONICAL_HOST"
   echo
   echo "m4_pattern_forbid([^gl_[A-Z]])dnl the gnulib macro namespace"
   echo "m4_pattern_allow([^gl_ES\$])dnl a valid locale name"
   echo "m4_pattern_allow([^gl_LIBOBJS\$])dnl a variable"
   echo "m4_pattern_allow([^gl_LTLIBOBJS\$])dnl a variable"

   func_emit_pre_early_macros false '' "$final_modules"

   if test -n "$any_uses_subdirs"; then
     echo "AM_PROG_CC_C_O"
     echo
   fi
   for module in $final_modules; do
     if $single_configure; then
       func_verify_module
     else
       func_verify_nontests_module
     fi
     if test -n "$module"; then
       func_get_autoconf_early_snippet "$module"
     fi
   done \
     | sed -e '/^$/d;' -e 's/AC_REQUIRE(\[\([^()]*\)\])/\1/'
   if test "$libtool" = true; then
     echo "LT_INIT([win32-dll])"
     echo "LT_LANG([C++])"
     echo "AM_CONDITIONAL([GL_COND_LIBTOOL], [true])"
     echo "gl_cond_libtool=true"
   else
     echo "AM_CONDITIONAL([GL_COND_LIBTOOL], [false])"
     echo "gl_cond_libtool=false"
     echo "gl_libdeps="
     echo "gl_ltlibdeps="
   fi
   # Wrap the set of autoconf snippets into an autoconf macro that is then
   # invoked. This is needed because autoconf does not support AC_REQUIRE
   # at the top level:
   #   error: AC_REQUIRE(gt_CSHARPCOMP): cannot be used outside of an AC_DEFUN'd macro
   # but we want the AC_REQUIRE to have its normal meaning (provide one
   # expansion of the required macro before the current point, and only one
   # expansion total).
   echo "AC_DEFUN([gl_INIT], ["
   if test "$auxdir" != "build-aux"; then
     sed_replace_build_aux='
       :a
       /AC_CONFIG_FILES(.*:build-aux\/.*)/{
         s|AC_CONFIG_FILES(\(.*\):build-aux/\(.*\))|AC_CONFIG_FILES(\1:'"$auxdir"'/\2)|
         ba
       }'
   else
     sed_replace_build_aux="$sed_noop"
   fi
   echo "gl_m4_base='$m4base'"
   func_emit_initmacro_start $macro_prefix
   echo "gl_source_base='$sourcebase'"
   if $single_configure; then
     func_emit_autoconf_snippets "$main_modules" "$main_modules" func_verify_module true false false
   else
     func_emit_autoconf_snippets "$modules" "$modules" func_verify_nontests_module true false false
   fi
   func_emit_initmacro_end $macro_prefix
   if $single_configure; then
     echo "  gltests_libdeps="
     echo "  gltests_ltlibdeps="
     func_emit_initmacro_start ${macro_prefix}tests
     echo "  gl_source_base='$testsbase'"
     # Define a tests witness macro.
     echo "  ${macro_prefix}tests_WITNESS=IN_GNULIB_TESTS"
     echo "  AC_SUBST([${macro_prefix}tests_WITNESS])"
     echo "  gl_module_indicator_condition=\$${macro_prefix}tests_WITNESS"
     echo "  m4_pushdef([gl_MODULE_INDICATOR_CONDITION], [\$gl_module_indicator_condition])"
     func_emit_autoconf_snippets "$testsrelated_modules" "$main_modules $testsrelated_modules" func_verify_module true false false
     echo "  m4_popdef([gl_MODULE_INDICATOR_CONDITION])"
     func_emit_initmacro_end ${macro_prefix}tests
   fi
   # _LIBDEPS and _LTLIBDEPS variables are not needed if this library is
   # created using libtool, because libtool already handles the dependencies.
   if test "$libtool" != true; then
     libname_upper=`echo "$libname" | LC_ALL=C tr '[a-z]-' '[A-Z]_'`
     echo "  ${libname_upper}_LIBDEPS=\"\$gl_libdeps\""
     echo "  AC_SUBST([${libname_upper}_LIBDEPS])"
     echo "  ${libname_upper}_LTLIBDEPS=\"\$gl_ltlibdeps\""
     echo "  AC_SUBST([${libname_upper}_LTLIBDEPS])"
   fi
   if $single_configure; then
     if $use_libtests; then
       echo "  LIBTESTS_LIBDEPS=\"\$gltests_libdeps\""
       echo "  AC_SUBST([LIBTESTS_LIBDEPS])"
     fi
   fi
   echo "])"
   func_emit_initmacro_done $macro_prefix $sourcebase
   if $single_configure; then
     func_emit_initmacro_done ${macro_prefix}tests $testsbase
   fi
   echo
   echo "gl_INIT"
   echo
   if test -n "$subdirs_with_configure_ac"; then
     echo "AC_CONFIG_SUBDIRS(["`echo $subdirs_with_configure_ac`"])"
   fi
   makefiles="Makefile"
   for d in $subdirs; do
     # For subdirs that have a configure.ac by their own, it's the subdir's
     # configure.ac which creates the subdir's Makefile.am, not this one.
     case " $subdirs_with_configure_ac " in
       *" $d "*) ;;
       *) func_append makefiles " $d/Makefile" ;;
     esac
   done
   echo "AC_CONFIG_FILES([$makefiles])"
   echo "AC_OUTPUT"
  ) > "$testdir/configure.ac"

  # Create autogenerated files.
  (cd "$testdir"
   # Do not use "${AUTORECONF} --force --install", because it may invoke
   # autopoint, which brings in older versions of some of our .m4 files.
   if test -f $m4base/gettext.m4; then
     func_execute_command ${AUTOPOINT} --force || func_exit 1
     for f in $m4base/*.m4~; do
       if test -f $f; then
         mv -f $f `echo $f | sed -e 's,~$,,'` || func_exit 1
       fi
     done
   fi
   if test "$libtool" = true; then
     func_execute_command ${LIBTOOLIZE} --copy || func_exit 1
   fi
   func_execute_command ${ACLOCAL} -I $m4base || func_exit 1
   if ! test -d build-aux; then
     func_execute_command mkdir build-aux || func_exit 1
   fi
   func_execute_command ${AUTOCONF} || func_exit 1
   # Explicit 'touch config.h.in': see <https://savannah.gnu.org/support/index.php?109406>.
   func_execute_command ${AUTOHEADER} &&
       func_execute_command touch config.h.in ||
           func_exit 1
   func_execute_command ${AUTOMAKE} --add-missing --copy || func_exit 1
   rm -rf autom4te.cache
  ) || func_exit 1
  if $inctests && ! $single_configure; then
    # Create autogenerated files.
    (cd "$testdir/$testsbase" || func_exit 1
     # Do not use "${AUTORECONF} --force --install", because it may invoke
     # autopoint, which brings in older versions of some of our .m4 files.
     if test -f ../$m4base/gettext.m4; then
       func_execute_command ${AUTOPOINT} --force || func_exit 1
       for f in ../$m4base/*.m4~; do
         if test -f $f; then
           mv -f $f `echo $f | sed -e 's,~$,,'` || func_exit 1
         fi
       done
     fi
     func_execute_command ${ACLOCAL} -I ../$m4base || func_exit 1
     if ! test -d ../build-aux; then
       func_execute_command mkdir ../build-aux
     fi
     func_execute_command ${AUTOCONF} || func_exit 1
     # Explicit 'touch config.h.in': see <https://savannah.gnu.org/support/index.php?109406>.
     func_execute_command ${AUTOHEADER} &&
         func_execute_command touch config.h.in ||
             func_exit 1
     func_execute_command ${AUTOMAKE} --add-missing --copy || func_exit 1
     rm -rf autom4te.cache
    ) || func_exit 1
  fi
  # Need to run configure and make once, to create built files that are to be
  # distributed (such as parse-datetime.c).
  sed_remove_make_variables='s,[$]([A-Za-z0-9_]*),,g'
  # Extract the value of "CLEANFILES += ..." and "MOSTLYCLEANFILES += ...".
  cleaned_files=`combine_lines < "$testdir/$sourcebase/Makefile.am" \
                 | sed -n -e 's,^CLEANFILES[     ]*+=\([^#]*\).*$,\1,p' -e 's,^MOSTLYCLEANFILES[         ]*+=\([^#]*\).*$,\1,p'`
  cleaned_files=`for file in $cleaned_files; do echo " $file "; done`
  # Extract the value of "BUILT_SOURCES += ...". Remove variable references
  # such $(FOO_H) because they don't refer to distributed files.
  built_sources=`combine_lines < "$testdir/$sourcebase/Makefile.am" \
                 | sed -n -e 's,^BUILT_SOURCES[  ]*+=\([^#]*\).*$,\1,p' \
                 | sed -e "$sed_remove_make_variables"`
  distributed_built_sources=`for file in $built_sources; do
                               case "$cleaned_files" in
                                 *" "$file" "*) ;;
                                 *) echo $file ;;
                               esac;
                             done`
  tests_distributed_built_sources=
  if $inctests; then
    # Likewise for built files in the $testsbase directory.
    tests_cleaned_files=`combine_lines < "$testdir/$testsbase/Makefile.am" \
                         | sed -n -e 's,^CLEANFILES[     ]*+=\([^#]*\).*$,\1,p' -e 's,^MOSTLYCLEANFILES[         ]*+=\([^#]*\).*$,\1,p'`
    tests_cleaned_files=`for file in $tests_cleaned_files; do echo " $file "; done`
    tests_built_sources=`combine_lines < "$testdir/$testsbase/Makefile.am" \
                         | sed -n -e 's,^BUILT_SOURCES[  ]*+=\([^#]*\).*$,\1,p' \
                         | sed -e "$sed_remove_make_variables"`
    tests_distributed_built_sources=`for file in $tests_built_sources; do
                                       case "$tests_cleaned_files" in
                                         *" "$file" "*) ;;
                                         *) echo $file ;;
                                       esac;
                                     done`
  fi
  if test -n "$distributed_built_sources" || test -n "$tests_distributed_built_sources"; then
    (cd "$testdir"
     ./configure || func_exit 1
     if test -n "$distributed_built_sources"; then
       cd "$sourcebase"
       echo 'built_sources: $(BUILT_SOURCES)' >> Makefile
       $MAKE AUTOCONF="${AUTOCONF}" AUTOHEADER="${AUTOHEADER}" ACLOCAL="${ACLOCAL}" AUTOMAKE="${AUTOMAKE}" AUTORECONF="${AUTORECONF}" AUTOPOINT="${AUTOPOINT}" LIBTOOLIZE="${LIBTOOLIZE}" \
             built_sources \
         || func_exit 1
       cd ..
     fi
     if test -n "$tests_distributed_built_sources"; then
       cd "$testsbase"
       echo 'built_sources: $(BUILT_SOURCES)' >> Makefile
       $MAKE AUTOCONF="${AUTOCONF}" AUTOHEADER="${AUTOHEADER}" ACLOCAL="${ACLOCAL}" AUTOMAKE="${AUTOMAKE}" AUTORECONF="${AUTORECONF}" AUTOPOINT="${AUTOPOINT}" LIBTOOLIZE="${LIBTOOLIZE}" \
             built_sources \
         || func_exit 1
       cd ..
     fi
     $MAKE AUTOCONF="${AUTOCONF}" AUTOHEADER="${AUTOHEADER}" ACLOCAL="${ACLOCAL}" AUTOMAKE="${AUTOMAKE}" AUTORECONF="${AUTORECONF}" AUTOPOINT="${AUTOPOINT}" LIBTOOLIZE="${LIBTOOLIZE}" \
           distclean \
       || func_exit 1
    ) || func_exit 1
  fi
  (cd "$testdir"
   if test -f build-aux/test-driver; then
     patch build-aux/test-driver < "$gnulib_dir"/build-aux/test-driver.diff || func_exit 1
   fi
  ) || func_exit 1
}

# func_create_megatestdir megatestdir allmodules
# Input:
# - local_gnulib_path  from --local-dir
# - modcache        true or false, from --cache-modules/--no-cache-modules
# - auxdir          directory relative to destdir where to place build aux files
func_create_megatestdir ()
{
  megatestdir="$1"
  allmodules="$2"
  if test -z "$allmodules"; then
    allmodules=`func_all_modules`
  fi

  megasubdirs=
  # First, all modules one by one.
  for onemodule in $allmodules; do
    func_create_testdir "$megatestdir/$onemodule" $onemodule
    func_append megasubdirs "$onemodule "
  done
  # Then, all modules all together.
  # Except config-h, which breaks all modules which use HAVE_CONFIG_H.
  allmodules=`for m in $allmodules; do if test $m != config-h; then echo $m; fi; done`
  func_create_testdir "$megatestdir/ALL" "$allmodules"
  func_append megasubdirs "ALL"

  # Create autobuild.
  cvsdate=`vc_witness="$gnulib_dir/.git/refs/heads/master"; \
           sh "$gnulib_dir/build-aux/mdate-sh" "$vc_witness" \
             | sed -e 's,January,01,'   -e 's,Jan,01,' \
                   -e 's,February,02,'  -e 's,Feb,02,' \
                   -e 's,March,03,'     -e 's,Mar,03,' \
                   -e 's,April,04,'     -e 's,Apr,04,' \
                   -e 's,May,05,'                      \
                   -e 's,June,06,'      -e 's,Jun,06,' \
                   -e 's,July,07,'      -e 's,Jul,07,' \
                   -e 's,August,08,'    -e 's,Aug,08,' \
                   -e 's,September,09,' -e 's,Sep,09,' \
                   -e 's,October,10,'   -e 's,Oct,10,' \
                   -e 's,November,11,'  -e 's,Nov,11,' \
                   -e 's,December,12,'  -e 's,Dec,12,' \
                   -e 's,^,00,' -e 's,^[0-9]*\([0-9][0-9] \),\1,' \
                   -e 's,^\([0-9]*\) \([0-9]*\) \([0-9]*\),\3\2\1,'`
  (echo '#!/bin/sh'
   echo "CVSDATE=$cvsdate"
   echo ": \${MAKE=make}"
   echo "test -d logs || mkdir logs"
   echo "for module in $megasubdirs; do"
   echo "  echo \"Working on module \$module...\""
   echo "  safemodule=\`echo \$module | sed -e 's|/|-|g'\`"
   echo "  (echo \"To: gnulib@autobuild.josefsson.org\""
   echo "   echo"
   echo "   set -x"
   echo "   : autobuild project... \$module"
   echo "   : autobuild revision... cvs-\$CVSDATE-000000"
   echo "   : autobuild timestamp... \`date \"+%Y%m%d-%H%M%S\"\`"
   echo "   : autobuild hostname... \`hostname\`"
   echo "   cd \$module && ./configure \$CONFIGURE_OPTIONS && \$MAKE && \$MAKE check && \$MAKE distclean"
   echo "   echo rc=\$?"
   echo "  ) 2>&1 | { if test -n \"\$AUTOBUILD_SUBST\"; then sed -e \"\$AUTOBUILD_SUBST\"; else cat; fi; } > logs/\$safemodule"
   echo "done"
  ) > "$megatestdir/do-autobuild"
  chmod a+x "$megatestdir/do-autobuild"

  # Create Makefile.am.
  (echo "## Process this file with automake to produce Makefile.in."
   echo
   echo "AUTOMAKE_OPTIONS = 1.11 foreign"
   echo
   echo "SUBDIRS = $megasubdirs"
   echo
   echo "EXTRA_DIST = do-autobuild"
  ) > "$megatestdir/Makefile.am"

  # Create configure.ac.
  (echo "# Process this file with autoconf to produce a configure script."
   echo "AC_INIT([dummy], [0])"
   if test "$auxdir" != "."; then
     echo "AC_CONFIG_AUX_DIR([$auxdir])"
   fi
   echo "AM_INIT_AUTOMAKE"
   echo
   echo "AC_PROG_MAKE_SET"
   echo
   echo "AC_CONFIG_SUBDIRS([$megasubdirs])"
   echo "AC_CONFIG_FILES([Makefile])"
   echo "AC_OUTPUT"
  ) > "$megatestdir/configure.ac"

  # Create autogenerated files.
  (cd "$megatestdir"
   # Do not use "${AUTORECONF} --install", because autoreconf operates
   # recursively, but the subdirectories are already finished, therefore
   # calling autoreconf here would only waste lots of CPU time.
   func_execute_command ${ACLOCAL} || func_exit 1
   func_execute_command mkdir build-aux
   func_execute_command ${AUTOCONF} || func_exit 1
   func_execute_command ${AUTOMAKE} --add-missing --copy || func_exit 1
   rm -rf autom4te.cache
   if test -f build-aux/test-driver; then
     patch build-aux/test-driver < "$gnulib_dir"/build-aux/test-driver.diff || func_exit 1
   fi
  ) || func_exit 1
}

case $mode in
  "" )
    func_fatal_error "no mode specified" ;;

  list )
    func_all_modules
    ;;

  find )
    # sed expression that converts a literal to a basic regular expression.
    # Needs to handle . [ \ * ^ $.
    sed_literal_to_basic_regex='s/\\/\\\\/g
s/\[/\\[/g
s/\^/\\^/g
s/\([.*$]\)/[\1]/g'
    for filename
    do
      if test -f "$gnulib_dir/$filename" \
         || func_lookup_local_file "$filename"; then
        filename_anywhere_regex=`echo "$filename" | sed -e "$sed_literal_to_basic_regex"`
        filename_line_regex='^'"$filename_anywhere_regex"'$'
        module_candidates=`
          {
            (cd "$gnulib_dir" && find modules -type f -print | xargs -n 100 grep -l "$filename_line_regex" /dev/null | sed -e 's,^modules/,,')
            func_path_foreach "$local_gnulib_path" func_modules_in_dir %dir% | xargs -n 100 grep -l "$filename_anywhere_regex" /dev/null | sed -e 's,^modules/,,' -e 's,\.diff$,,'
          } \
            | func_sanitize_modulelist \
            | LC_ALL=C sort -u
          `
        for module in $module_candidates; do
          if func_get_filelist $module | grep "$filename_line_regex" > /dev/null; then
            echo $module
          fi
        done
      else
        func_warning "file $filename does not exist"
      fi
    done
    ;;

  import | add-import | remove-import | update )

    # Where to import.
    if test -z "$destdir"; then
      destdir=.
    fi
    test -d "$destdir" \
      || func_fatal_error "destination directory does not exist: $destdir"

    # Prefer configure.ac to configure.in.
    if test -f "$destdir"/configure.ac; then
      configure_ac="$destdir/configure.ac"
    else
      if test -f "$destdir"/configure.in; then
        configure_ac="$destdir/configure.in"
      else
        func_fatal_error "cannot find $destdir/configure.ac - make sure you run gnulib-tool from within your package's directory"
      fi
    fi

    # Analyze configure.ac.
    guessed_auxdir="."
    guessed_libtool=false
    my_sed_traces='
      s,#.*$,,
      s,^dnl .*$,,
      s, dnl .*$,,
      /AC_CONFIG_AUX_DIR/ {
        s,^.*AC_CONFIG_AUX_DIR([[ ]*\([^]"$`\\)]*\).*$,guessed_auxdir="\1",p
      }
      /A[CM]_PROG_LIBTOOL/ {
        s,^.*$,guessed_libtool=true,p
      }'
    eval `sed -n -e "$my_sed_traces" < "$configure_ac"`

    if test -z "$auxdir"; then
      auxdir="$guessed_auxdir"
    fi

    # Determine where to apply func_import.
    if test "$mode" = import; then
      # Apply func_import to a particular gnulib directory.
      # The command line contains the complete specification; don't look at
      # the contents of gnulib-cache.m4.
      test -n "$supplied_libname" || supplied_libname=true
      test -n "$sourcebase" || sourcebase="lib"
      test -n "$m4base" || m4base="m4"
      test -n "$docbase" || docbase="doc"
      test -n "$testsbase" || testsbase="tests"
      test -n "$macro_prefix" || macro_prefix="gl"
      func_import "$*"
    else
      if test -n "$m4base"; then
        # Apply func_import to a particular gnulib directory.
        # Any number of additional modules can be given.
        if test ! -f "$destdir/$m4base"/gnulib-cache.m4; then
          # First use of gnulib in the given m4base.
          test -n "$supplied_libname" || supplied_libname=true
          test -n "$sourcebase" || sourcebase="lib"
          test -n "$docbase" || docbase="doc"
          test -n "$testsbase" || testsbase="tests"
          test -n "$macro_prefix" || macro_prefix="gl"
        fi
        func_import "$*"
      else
        # Apply func_import to all gnulib directories.
        # To get this list of directories, look at Makefile.am. (Not at
        # configure, because it may be omitted from version control. Also,
        # don't run "find $destdir -name gnulib-cache.m4", as it might be
        # too expensive.)
        m4dirs=
        m4dirs_count=0
        if test -f "$destdir"/Makefile.am; then
          aclocal_amflags=`sed -n -e 's/^ACLOCAL_AMFLAGS[        ]*=\(.*\)$/\1/p' "$destdir"/Makefile.am`
          m4dir_is_next=
          for arg in $aclocal_amflags; do
            if test -n "$m4dir_is_next"; then
              # Ignore absolute directory pathnames, like /usr/local/share/aclocal.
              case "$arg" in
                /*) ;;
                *)
                  if test -f "$destdir/$arg"/gnulib-cache.m4; then
                    func_append m4dirs " $arg"
                    m4dirs_count=`expr $m4dirs_count + 1`
                  fi
                  ;;
              esac
              m4dir_is_next=
            else
              if test "X$arg" = "X-I"; then
                m4dir_is_next=yes
              else
                m4dir_is_next=
              fi
            fi
          done
        else
          # No Makefile.am! Oh well. Look at the last generated aclocal.m4.
          if test -f "$destdir"/aclocal.m4; then
            sedexpr1='s,^m4_include(\[\(.*\)])$,\1,p'
            sedexpr2='s,^[^/]*$,.,'
            sedexpr3='s,/[^/]*$,,'
            m4dirs=`sed -n -e "$sedexpr1" aclocal.m4 | sed -e "$sedexpr2" -e "$sedexpr3" | LC_ALL=C sort -u`
            m4dirs=`for arg in $m4dirs; do if test -f "$destdir/$arg"/gnulib-cache.m4; then echo $arg; fi; done`
            m4dirs_count=`for arg in $m4dirs; do echo "$arg"; done | wc -l`
          fi
        fi
        if test $m4dirs_count = 0; then
          # First use of gnulib in a package.
          # Any number of additional modules can be given.
          test -n "$supplied_libname" || supplied_libname=true
          test -n "$sourcebase" || sourcebase="lib"
          m4base="m4"
          test -n "$docbase" || docbase="doc"
          test -n "$testsbase" || testsbase="tests"
          test -n "$macro_prefix" || macro_prefix="gl"
          func_import "$*"
        else
          if test $m4dirs_count = 1; then
            # There's only one use of gnulib here. Assume the user means it.
            # Any number of additional modules can be given.
            for m4base in $m4dirs; do
              func_import "$*"
            done
          else
            # Ambiguous - guess what the user meant.
            if test $# = 0; then
              # No further arguments. Guess the user wants to update all of them.
              for m4base in $m4dirs; do
                # Perform func_import in a subshell, so that variable values
                # such as
                #   local_gnulib_path, incobsolete, inc_cxx_tests,
                #   inc_longrunning_tests, inc_privileged_tests,
                #   inc_unportable_tests, inc_all_tests, avoidlist, sourcebase,
                #   m4base, pobase, docbase, testsbase, inctests, libname, lgpl,
                #   makefile_name, libtool, macro_prefix, po_domain,
                #   witness_c_macro, vc_files
                # don't propagate from one directory to another.
                (func_import) || func_exit 1
              done
            else
              # Really ambiguous.
              func_fatal_error "Ambiguity: to which directory should the modules be added? Please specify at least --m4-base=..."
            fi
          fi
        fi
      fi
    fi
    ;;

  create-testdir )
    if test -z "$destdir"; then
      func_fatal_error "please specify --dir option"
    fi
    mkdir "$destdir"
    test -d "$destdir" \
      || func_fatal_error "could not create destination directory"
    test -n "$auxdir" || auxdir="build-aux"
    func_create_testdir "$destdir" "$*"
    ;;

  create-megatestdir )
    if test -z "$destdir"; then
      func_fatal_error "please specify --dir option"
    fi
    mkdir "$destdir" || func_fatal_error "could not create destination directory"
    test -n "$auxdir" || auxdir="build-aux"
    func_create_megatestdir "$destdir" "$*"
    ;;

  test )
    test -n "$destdir" || destdir=testdir$$
    mkdir "$destdir" || func_fatal_error "could not create destination directory"
    test -n "$auxdir" || auxdir="build-aux"
    func_create_testdir "$destdir" "$*"
    cd "$destdir"
      mkdir build
      cd build
        ../configure || func_exit 1
        $MAKE || func_exit 1
        $MAKE check || func_exit 1
        $MAKE distclean || func_exit 1
        remaining=`find . -type f -print`
        if test -n "$remaining"; then
          echo "Remaining files:" $remaining 1>&2
          echo "gnulib-tool: *** Stop." 1>&2
          func_exit 1
        fi
      cd ..
    cd ..
    rm -rf "$destdir"
    ;;

  megatest )
    test -n "$destdir" || destdir=testdir$$
    mkdir "$destdir" || func_fatal_error "could not create destination directory"
    test -n "$auxdir" || auxdir="build-aux"
    func_create_megatestdir "$destdir" "$*"
    cd "$destdir"
      mkdir build
      cd build
        ../configure
        $MAKE
        $MAKE check
        $MAKE distclean
        remaining=`find . -type f -print`
        if test -n "$remaining"; then
          echo "Remaining files:" $remaining 1>&2
          echo "gnulib-tool: *** Stop." 1>&2
          func_exit 1
        fi
      cd ..
    cd ..
    rm -rf "$destdir"
    ;;

  extract-description )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_description "$module"
      fi
    done
    ;;

  extract-comment )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_comment "$module"
      fi
    done
    ;;

  extract-status )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_status "$module"
      fi
    done
    ;;

  extract-notice )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_notice "$module"
      fi
    done
    ;;

  extract-applicability )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_applicability "$module"
      fi
    done
    ;;

  extract-filelist )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_filelist "$module"
      fi
    done
    ;;

  extract-dependencies )
    if test -n "$avoidlist"; then
      func_fatal_error "cannot combine --avoid and --extract-dependencies"
    fi
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_dependencies "$module"
      fi
    done
    ;;

  extract-recursive-dependencies )
    if test -n "$avoidlist"; then
      func_fatal_error "cannot combine --avoid and --extract-recursive-dependencies"
    fi
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_dependencies_recursively "$module"
      fi
    done
    ;;

  extract-autoconf-snippet )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_autoconf_snippet "$module"
      fi
    done
    ;;

  extract-automake-snippet )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_automake_snippet "$module"
      fi
    done
    ;;

  extract-include-directive )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_include_directive "$module"
      fi
    done
    ;;

  extract-link-directive )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_link_directive "$module"
      fi
    done
    ;;

  extract-recursive-link-directive )
    if test -n "$avoidlist"; then
      func_fatal_error "cannot combine --avoid and --extract-recursive-link-directive"
    fi
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_link_directive_recursively "$module"
      fi
    done
    ;;

  extract-license )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_license "$module"
      fi
    done
    ;;

  extract-maintainer )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_maintainer "$module"
      fi
    done
    ;;

  extract-tests-module )
    for module
    do
      func_verify_module
      if test -n "$module"; then
        func_get_tests_module "$module"
      fi
    done
    ;;

  copy-file )
    # Verify the number of arguments.
    if test $# -lt 1 || test $# -gt 2; then
      func_fatal_error "invalid number of arguments for --$mode"
    fi

    # The first argument is the file to be copied.
    f="$1"
    # Verify the file exists.
    func_lookup_file "$f"

    # The second argument is the destination; either a directory ot a file.
    # It defaults to the current directory.
    dest="$2"
    test -n "$dest" || dest='.'
    test -n "$sourcebase" || sourcebase="lib"
    test -n "$m4base" || m4base="m4"
    test -n "$docbase" || docbase="doc"
    test -n "$testsbase" || testsbase="tests"
    test -n "$auxdir" || auxdir="build-aux"
    rewritten='%REWRITTEN%'
    sed_rewrite_files="\
      s,^build-aux/,$rewritten$auxdir/,
      s,^doc/,$rewritten$docbase/,
      s,^lib/,$rewritten$sourcebase/,
      s,^m4/,$rewritten$m4base/,
      s,^tests/,$rewritten$testsbase/,
      s,^top/,$rewritten,
      s,^$rewritten,,"
    if test -d "$dest"; then
      destdir="$dest"
      g=`echo "$f" | sed -e "$sed_rewrite_files"`
    else
      destdir=`dirname "$dest"`
      g=`basename "$dest"`
    fi

    # Create the directory for destfile.
    d=`dirname "$destdir/$g"`
    if $doit; then
      if test -n "$d" && test ! -d "$d"; then
        mkdir -p "$d" || func_fatal_error "failed"
      fi
    fi
    # Copy the file.
    func_dest_tmpfilename "$g"
    cp "$lookedup_file" "$tmpfile" || func_fatal_error "failed"
    func_ensure_writable "$tmpfile"
    already_present=true
    if test -f "$destdir/$g"; then
      # The file already exists.
      func_update_file
    else
      # Install the file.
      # Don't protest if the file should be there but isn't: it happens
      # frequently that developers don't put autogenerated files under version
      # control.
      func_add_file
    fi
    rm -f "$tmpfile"
    ;;

  * )
    func_fatal_error "unknown operation mode --$mode" ;;
esac

if test "$copymode" = hardlink -o "$lcopymode" = hardlink; then
  # Setting hard links modifies the ctime of files in the gnulib checkout.
  # This disturbs the result of the next "gitk" invocation.
  # Workaround: Let git scan the files. This can be done through
  # "git update-index --refresh" or "git status" or "git diff".
  if test -d "$gnulib_dir"/.git \
     && (git --version) >/dev/null 2>/dev/null; then
    (cd "$gnulib_dir" && git update-index --refresh >/dev/null)
  fi
fi

rm -rf "$tmp"
# Undo the effect of the previous 'trap' command. Some shellology:
# We cannot use "trap - 0 1 2 3 13 15", because Solaris sh would attempt to
# execute the command "-". "trap '' ..." is fine only for signal 0 (= normal
# exit); for the others we need to call 'exit' explicitly. The value of $? is
# 128 + signal number and is set before the trap-registered command is run.
trap '' 0
trap 'func_exit $?' 1 2 3 13 15

exit 0

# Local Variables:
# indent-tabs-mode: nil
# whitespace-check-buffer-indent: nil
# End: