mirror of
git://git.savannah.gnu.org/libtool.git
synced 2024-11-21 01:40:57 +08:00
d576fa9da1
See maintain.texi (Copyright Notices) for rules for maintaining the years in copyright notices. * All Files (Copyright): Updated with missing 2011 and 2012. Signed-off-by: Gary V. Vaughan <gary@gnu.org>
666 lines
24 KiB
Plaintext
666 lines
24 KiB
Plaintext
m4_include([general.m4sh])m4_divert_push([KILL]) -*- Autoconf -*-
|
|
# getopt.m4sh -- getopt helper functions
|
|
#
|
|
# Copyright (C) 2004-2012 Free Software Foundation, Inc.
|
|
# Written by Gary V. Vaughan, 2004
|
|
#
|
|
# This file is part of GNU Libtool.
|
|
#
|
|
# GNU Libtool is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License as
|
|
# published by the Free Software Foundation; either version 2 of
|
|
# the License, or (at your option) any later version.
|
|
#
|
|
# As a special exception to the GNU General Public License, if you
|
|
# distribute this file as part of a program or library that contains
|
|
# a configuration script generated by Autoconf, you may include this
|
|
# file under the same distribution terms that you use for the rest
|
|
# of that program.
|
|
#
|
|
# GNU Libtool is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNES FOR A PARTICULAR PURPOSE. See the GNU
|
|
# General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with GNU Libtool; see the file COPYING. If not, a copy
|
|
# can be downloaded from http://www.gnu.org/licenses/gpl.html,
|
|
# or obtained by writing to the Free Software Foundation, Inc.,
|
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
# This file provides the M4SH_GETOPTS option processing compiler, and
|
|
# all necessary support at the m4 and shell-script levels.
|
|
#
|
|
# An m4sh script can include this file, and an M4SH_GETOPTS invocation
|
|
# that expands to a shell script option processing loop with similar
|
|
# abilites to a C program the uses getopt_long() to process it's command
|
|
# line options - although, unlike the C API, M4SH_GETOPTS also supplies
|
|
# the loop to step through and process the options.
|
|
#
|
|
# See the comment above M4SH_GETOPTS, below, for details.
|
|
|
|
|
|
# All internal macros begin with `m4go_'.
|
|
m4_pattern_forbid([^_?m4go_])
|
|
|
|
|
|
## --------------------------- ##
|
|
## 1. Backwards compatibility. ##
|
|
## --------------------------- ##
|
|
|
|
# We prefer m4sugar.m4 from Autoconf-2.64, but have fallbacks in this
|
|
# section that work back as far as Autoconf-2.62. This file is used
|
|
# at bootstrap time to generate the shell processing loop for ltmain.sh
|
|
# and libtoolize.in, so it's okay for the requirement to be tighter
|
|
# than the configure time Autoconf prerequisite version.
|
|
m4_version_prereq([2.62])
|
|
|
|
# m4_chomp(STRING)
|
|
# ----------------
|
|
# m4_chomp was not introduced until Autoconf-2.64. Currently we
|
|
# only use it indirectly via m4go_expand, below. This implementation
|
|
# is taken from Autoconf-2.65.
|
|
m4_ifndef([m4_chomp],
|
|
[m4_define([m4_chomp],
|
|
[m4_format([[%.*s]], m4_index(m4_translit([[$1]], [
|
|
/.], [/ ])[./.], [/.]), [$1])])])
|
|
|
|
# m4go_expand(ARG)
|
|
# ----------------
|
|
# M4SH_GETOPTS wants to pass unbalanced parentheses to m4_expand to
|
|
# build the branches of a shell `case' statement. That is only
|
|
# supported by the implementation of m4_expand in Autoconf-2.64 and
|
|
# newer. Since we want to be compatible back to at least
|
|
# Autoconf-2.62, reimplement our own 2.64 based m4_expand in the
|
|
# m4go_ namespace so that we can be compatible with Autoconf versions
|
|
# supporting either semantic.
|
|
m4_define([m4go_expand],
|
|
[m4_chomp(_$0([$1
|
|
]))])
|
|
|
|
m4_define([_m4go_expand], [$0_([$1], [(], -=<{($1)}>=-, [}>=-])])
|
|
|
|
m4_define([_m4go_ignore])
|
|
|
|
m4_define([_m4go_expand_],
|
|
[m4_if([$4], [}>=-],
|
|
[m4_changequote([-=<{$2], [)}>=-])$3m4_changequote([, ])],
|
|
[$0([$1], [($2], -=<{($2$1)}>=-, [}>=-])_m4go_ignore$2])])
|
|
|
|
|
|
## --------------------------------- ##
|
|
## 2. Low level string manipulation. ##
|
|
## --------------------------------- ##
|
|
|
|
# m4go_slice(STRING, BEGIN, END)
|
|
# ------------------------------
|
|
# Just like m4_substr(), except that both the BEGIN and END of the
|
|
# substring are given as offsets from the beginning of STRING, as
|
|
# returned by m4_index().
|
|
m4_define([m4go_slice],
|
|
[m4_substr([$1], [$2], m4_eval([$3-$2]))])
|
|
|
|
# m4go_trimn(STRING)
|
|
# -------------------
|
|
# Trim all leading and trailing newlines from STRING.
|
|
#
|
|
# Inspite of careful quoting, this macro is NOT robust to active
|
|
# symbols:
|
|
# | m4_define(active, ACTV)
|
|
# | m4go_trimn([[
|
|
# | start active finish
|
|
# | ]])
|
|
# => start ACTV fini
|
|
# The interaction between index counting and macro expansion also
|
|
# results in overtrimming in this example by 2 characters (the
|
|
# difference between the lengths of `active' and `ACTV'). Translation
|
|
# into French is just a coincidence.
|
|
#
|
|
# The implementation is surprisingly finicky: We use m4go_slice() to
|
|
# extract the middle section of the string, while using m4_bregexp() to
|
|
# return offset counts for the first and last non-newlines in STRING.
|
|
# But there are a number of corner cases:
|
|
# 1. Double quoted STRING works, (i.e m4go_trimn([[\nthe string\n]]. We
|
|
# achieve that by transliterating quote characters as well as
|
|
# newlines to the same character before counting off the offsets.
|
|
# 2. This needs a slightly different transliteration for each
|
|
# m4_bregexp() invocation, because we need to maintain balanced
|
|
# quotes in the argument and we don't want to swallow leading ']' or
|
|
# trailing '[' characters. So, we turn the quote we don't want to
|
|
# strip into a harmless ' '.
|
|
# 3. Because we're now effectively stripping the quotation with the
|
|
# m4_translit() calls, embedded commas can fool m4_bregexp() into
|
|
# thinking there are more arguments than we intended, so we turn
|
|
# them into spaces too.
|
|
# 4. Unbalanced parentheses would also confuse m4_bregexp(), so we also
|
|
# turn them into spaces. The upshot of that if STRING contains a
|
|
# macro invocation with arguments, it will be expanded in the result
|
|
# as if no arguments had been passed.
|
|
# 5. Comments are not ignored after stripping quote marks, so we have
|
|
# to turn them off for the duration.
|
|
# 6. Finally, we need to requote the result to account for the quotes
|
|
# we probably stripped. m4_quote() doesn't handle commas well, so
|
|
# we use m4go_expand() to requote without losing whitespace after
|
|
# any embedded commas.
|
|
m4_define([m4go_trimn],
|
|
[m4_changecom()m4go_expand([m4go_slice([$1], m4_bregexp(m4_translit([$1],[
|
|
[/,()]], [// ]), [[^/]]), m4_bregexp(m4_translit([$1], [
|
|
[/,()]], [/ /]), [/*$]))])[]m4_changecom([#])])
|
|
|
|
# m4go_untab(STRING)
|
|
# ------------------
|
|
# Trim leading TABs from each line of STRING.
|
|
m4_define([m4go_untab],
|
|
[m4_bpatsubst([$1], [^[ ]*], [])])
|
|
|
|
# m4go_unindent(STRING)
|
|
# ---------------------
|
|
# Completely unindent STRING: Remove the leading TABs from each line of
|
|
# STRING; trim leading newlines and trailing whitespace from STRING as
|
|
# a whole.
|
|
m4_define([m4go_unindent],
|
|
[m4_ifval([$1], [m4go_untab([m4go_trimn([$1])])])])
|
|
|
|
|
|
## ------------------------------ ##
|
|
## 3. Option processing compiler. ##
|
|
## ------------------------------ ##
|
|
|
|
# Shell fragments are piecemeal added to these macros for each
|
|
# invocation of m4go_option; eventually to be expanded into the compiled
|
|
# option parsing shell script by M4SH_GETOPTS:
|
|
|
|
m4_define([m4go_defaults], []) # initial shell option variable setings
|
|
m4_define([m4go_branches], []) # case branches to process options
|
|
|
|
# The initial entries in m4go_shortnoargs represent the (non-argument)
|
|
# options that are always accepted by the expanded processing loop. We
|
|
# also keep a list of short options that accept an option argument in
|
|
# the macro `m4go_shortargs', but we use `m4_append([m4go_shortargs],
|
|
# OPTION, [|])' to insert the separator pipe symbols - which requires
|
|
# that `m4go_shortargs' be undefined if the first option appended is not
|
|
# prefixed by a leading `|'.
|
|
m4_define([m4go_shortnoargs], [-\?*|-h*])
|
|
|
|
|
|
# M4SH_GETOPTS(SHORT-SPEC1, LONG-MATCH1, DEF1, INIT1,
|
|
# SHORT-SPEC2, LONG-MATCH2, DEF2, INIT2, ... [VALIDATION])
|
|
# ---------------------------------------------------------------------
|
|
# Declare a series of command line options with one letter (`-m') or
|
|
# long form `--message' formats, along with optional default values
|
|
# incase a given option is not provided by the user when the script is
|
|
# invoked, and validation code, for example to prevent specifying
|
|
# mutually exclusive options or omitting required options.
|
|
#
|
|
# After this macro has been called, the value of each option is
|
|
# available in a shell variable named `opt_' followed by the first part
|
|
# (i.e. up to the first '|' symbol) of the LONG-MATCHn argument with the
|
|
# leading `--` removed, and any further `-' converted to `_', or else if
|
|
# no long form option was provided, simple `opt_' followed by the short
|
|
# option letter. For example, the value supplied by the user as an
|
|
# argument to an option `--gpg-key-id' will be available in the shell
|
|
# variable $opt_gpg_key_id, `-c' with no long form option will be
|
|
# available as $opt_c and so on. Where an option doesn't take an
|
|
# argument, then the shell variable will be set to either `:' or `false'
|
|
# depending on whether the user set that option on the script command
|
|
# line - with one important exception: If the long form option name
|
|
# begins with `--no-', and does not require an option argument, then the
|
|
# variable name will be `opt_' followed by the rest of the option name
|
|
# with the leading `no_' removed; and it's value will be `false' if
|
|
# `--no-foo' was given on the command line, and `:' otherwise.
|
|
#
|
|
# Each option is declared by a set of 4 arguments as follows:
|
|
#
|
|
# SHORT-SPECn
|
|
# The short option letter, if any, for the nth option followed by
|
|
# any flags to denote special processing for this option. For
|
|
# example, `f?@'. See below for a list of the supported flags and
|
|
# their meaning. If you specify `h', `v' or `x', then the
|
|
# automatic processing of those short options for `--help',
|
|
# `--version' and `--debug' (resp.) will be overridden.
|
|
# LONG-MATCHn
|
|
# The long option list, including leading dashes for the nth
|
|
# option. The value for this option is used directly as a shell
|
|
# `case' branch to match the option, so you can specify multiple
|
|
# matches. For example, `--message|--mes*|--msg'. If you specify
|
|
# neither this argument nor a short option letter with
|
|
# SHORT-SPECn, then invalid shell code will be generated.
|
|
# DEFn If there is a default value for the nth option to take when it
|
|
# is not given on the command line when the script is executed,
|
|
# specify it here. Double quotes are added in the expanded shell
|
|
# script, so it is safe to use shell variables. For example,
|
|
# `$HOME/.foorc'.
|
|
# INITn Any option specific initialisation for the nth option should be
|
|
# specified in this argument. The shell code it contains is added
|
|
# directly to the case branch that matches the nth option, after
|
|
# the `opt_NAME' variable has been set, with the option argument
|
|
# (if any) still left in `$1'. This allows neat tricks such as
|
|
# injecting new arguments into the command line before the
|
|
# processing loop terminates. For example:
|
|
#
|
|
# eval set dummy `cat $rcfile` ${1+"$@"}; shift
|
|
#
|
|
# Note that, because we look inside the content of INITn to
|
|
# determine whether there are newlines to be stripped, double
|
|
# quoting the whele thing doesn't work. Instead, you'll need to
|
|
# quote active symbols yourself. Generally, you'll only need to
|
|
# worry about $n and $@, although if you use symbols that can be
|
|
# expanded by m4 you'll need to quote those too.
|
|
# VALIDATION
|
|
# The final argument, if any, should contain shell code to
|
|
# validate correctness of the processed options. This code is
|
|
# expanded after the option processing loop has exited, and before
|
|
# the conditional script exit if errors have been found. Try to
|
|
# show as many errors as possible before exiting the shell rather
|
|
# than bailing out on the first error discovered so that the user
|
|
# can correct all of them at once rather than just one between
|
|
# each reinvocation of the script.
|
|
#
|
|
# In addition to an option short form letter (e.g. `m'), each
|
|
# SHORT-SPECn argument can also list one or more of the following flags
|
|
# to place additional constraints on that option (only one of `?', `+'
|
|
# and `@' can be given in any SHORT-SPECn):
|
|
#
|
|
# =STRING
|
|
# The option does not take an argument, but when specified on the
|
|
# command line the `opt_' variable is set to STRING.
|
|
# ? The option takes an optional argument. Unless the next command
|
|
# line argument begins with a `-' it will be the value stored in
|
|
# this option's `opt_' shell variable. Otherwise the `opt_'
|
|
# variable will contain the INITn value.
|
|
# ! The option requires an argument. The next command line argument
|
|
# will be stored in this option's `opt_' shell variable, or else
|
|
# the INITn value, if any, will be stored if this option is not
|
|
# given on the command line.
|
|
# ; The same as `!', except that when the argument is given multiple
|
|
# times on the command line, each argument is appended to the
|
|
# `opt_' shell variable, along with a new-line to separate it from
|
|
# the previous argument.
|
|
# + The same as `!', except that each time the argument is supplied
|
|
# on the command line, it's value is stored in an `opt_' variable
|
|
# with `_n' appended to the variable name - where `n' is `1' for
|
|
# the first argument, `2, for the second and so on.
|
|
# @ The option argument must point to an existing file. The
|
|
# processing loop will automatically contain an additional check
|
|
# to ensure that the named file exists. `@' can be added to a
|
|
# SHORT-SPECn argument in addition to any other flags.
|
|
# ^ The value stored in the `opt_' variable is quoted by passing it
|
|
# through the shell function `func_quote_for_eval'.
|
|
#
|
|
# The M4SH_GETOPTS macro is implemented by first delegating to
|
|
# `_M4SH_GETOPTS', a shift4-loop that repeatedly calls `m4go_options',
|
|
# shifts away the 4 processed arguments, checks the number of remaining
|
|
# args and loops again until only 1 argument (VALIDATION) or 0 arguments
|
|
# (no VALIDATION code) remain. When all the processing is complete, we
|
|
# expand 'm4go_printopts' to write out the complete command line
|
|
# processing shell loop.
|
|
#
|
|
# Generally, you can combine the SHORT-SPECn flags in sensible ways,
|
|
# but no error checking is done. If you choose a combination that makes
|
|
# no sense, you'll probably end up with broken shell code.
|
|
m4_define([M4SH_GETOPTS],
|
|
[_$0($@)[]m4go_printopts])
|
|
m4_define([_M4SH_GETOPTS],
|
|
[m4_if([$#], 0, [],
|
|
[$#], 1, [m4_define([m4go_validation],[$1])],
|
|
[$#], 2, [m4_fatal([$0: too few arguments: $#: $2])],
|
|
[$#], 3, [m4_fatal([$0: too few arguments: $#: $3])],
|
|
[m4go_option($@)[]$0(m4_shiftn(4, $@))])])
|
|
|
|
|
|
# m4go_option(SHORT-SPEC, LONG-MATCH, DEFAULT, INIT)
|
|
# --------------------------------------------------
|
|
# This macro is a wrapper for `_m4go_option', which first extracts the
|
|
# short option letter (if any) from SHORT-SPEC, and then calculates the
|
|
# full `opt_' shell variable name for this option before delegating
|
|
# those results along with all of its own arguments to `_m4go_option'.
|
|
#
|
|
# Note that when the LONG-MATCH begins with `--no-', we add `~' to the
|
|
# list of SHORT-SPEC flags before calling `_m4go_option' to denote that
|
|
# the name of the `opt_' variable is reversed in the sense of the option
|
|
# name itself.That is, we want to start with the option being true, and
|
|
# set it to false if `--no-foo' is given on the command line.
|
|
#
|
|
# `m4_do' is used here to separate out the pushdef and popdef of the
|
|
# temporary `_short' macro used to held the extracted short option
|
|
# letter, if any.
|
|
m4_define([m4go_option],
|
|
[m4_do(
|
|
[m4_pushdef([_short],
|
|
m4_bmatch([$1],
|
|
[[?!;+@^]], m4_bpatsubst([$1], [[?!;+@^]*], []),
|
|
[^=], [],
|
|
[.], [[$1]],
|
|
[]))],
|
|
[_$0(opt_[]m4_ifval([$2],
|
|
m4_translit(m4_bpatsubst([$2], [^--\(no-\)?\([^|]+\).*$],
|
|
[\2]), -, _),
|
|
_short),
|
|
_short,
|
|
[$1]m4_bmatch([$2], [^--no-], [~]),
|
|
[$2],
|
|
[$3],
|
|
[$4])],
|
|
[m4_popdef([_short])])])
|
|
|
|
|
|
# _m4go_option(OPTION-NAME, SHORT-OPTION, SHORT-SPEC, LONG-MATCH,
|
|
# DEFAULT, INIT)
|
|
#----------------------------------------------------------------
|
|
# For this option, append the appropriate shell code fragments to:
|
|
# `m4go_defaults'
|
|
# A shell script fragment containing `opt_' variable
|
|
# initialisation according to DEFAULT, if necessary;
|
|
# `m4go_branches'
|
|
# The case branch to match any SHORT-OPTION or LONG-MATCH command
|
|
# line option, along with any automatic processing implied by
|
|
# SHORT-SPEC flags, and additional code from INIT;
|
|
# `m4go_shortargs'
|
|
# This match string accumulates all of the short options that
|
|
# accept option arguments, so that we can generate some additional
|
|
# code to split apart compacted option strings (`-xfoo' will be
|
|
# treated as if `-x foo' had been passed) in `m4go_printopts'.
|
|
# `m4go_shortnoargs'
|
|
# Similarly, accumulate short options that do not take option
|
|
# arguments, so that we can generate the code to split apart
|
|
# compacted options strings in `m4go_printopts' (`-xfoo' will be
|
|
# treated as if `-x -f -o -o' had been passed).
|
|
#
|
|
# The core of this macro switches the `m4go_branches' processing to an
|
|
# appropriate macro depending on what flags are present in SHORT-SPEC.
|
|
|
|
m4_define([_m4go_option],
|
|
[m4_do(
|
|
[m4_append([m4go_defaults],
|
|
m4_bmatch([$3],
|
|
[[?!;+@^]], [m4_ifval([$5], [m4_n([$1="$5"])])],
|
|
[~], [m4_n([$1=:])],
|
|
[m4_n([$1=false])]))],
|
|
[m4_append([m4go_branches], [[]dnl (
|
|
m4_join([|], [$4], m4_ifval([$2], [-$2])))
|
|
])],
|
|
[m4_append([m4go_branches],
|
|
[m4_bmatch([$3], [[!+@]],
|
|
[ test [$]# = 0 && func_missing_arg $opt && break
|
|
])m4_n(m4_bmatch([$3],
|
|
[\^], [ func_quote_for_eval "[$]1"
|
|
optarg=$func_quote_for_eval_result],
|
|
[[?!;+@]], [ optarg=[$]1]))[]dnl
|
|
m4_n(m4_bmatch([$3],
|
|
[+], [ $1_num=`expr 1 + ${$1_num-0}`
|
|
eval $1_${$1_num}=\"$optarg\"],
|
|
[?], [m4_bmatch([$3],
|
|
[@], [m4go_expand([m4go_optional_file_arg([$1])])],
|
|
[m4go_expand([m4go_optional_arg([$1])])])],
|
|
[[!@]], [ $1=$optarg],
|
|
[;], [ $1="${$1+[$]$1
|
|
}$optarg"],
|
|
[~], [ $1=false],
|
|
[=.], [ $1="m4_bpatsubst([$3], [^.*=], [])"],
|
|
[ $1=:]))[]dnl
|
|
dnl only write the file_arg fragment when we didn't already write opt_file_arg:
|
|
m4_bmatch([$3], [@], [m4_bmatch([$3], [?], [],
|
|
[m4go_expand([m4go_file_arg([$1])])
|
|
])])m4_n(m4go_unindent([$6]))[]dnl
|
|
m4_bmatch([$3], [[!+;]], [ shift
|
|
]) ;;
|
|
])],
|
|
[m4_ifval([$2],
|
|
[m4_bmatch([$3],
|
|
[[?!;+@^~]], [m4_append([m4go_shortargs], [-$2*], [|])],
|
|
[m4_append([m4go_shortnoargs], [-$2*],
|
|
[|])])])])])
|
|
|
|
|
|
# m4go_optional_arg(OPTION-NAME)
|
|
# ------------------------------
|
|
# Expand to the case branch core code for processing a flag that takes
|
|
# an optional argument, and sets the `opt_' variable named by
|
|
# OPTION-NAME appropriately.
|
|
m4_define([m4go_optional_arg],
|
|
[ if test [$]# -gt 0; then
|
|
case $optarg in # ((
|
|
-*) ;;
|
|
*) $1=$optarg; shift ;;
|
|
esac
|
|
fi])
|
|
|
|
# m4go_file_arg(OPTION-NAME)
|
|
# --------------------------
|
|
# As above, but for flags that require the name of an existing file as
|
|
# an argument.
|
|
m4_define([m4go_file_arg],
|
|
[ test -r "$optarg" || {
|
|
func_error "$opt: cannot read file \`$optarg'."
|
|
exit_cmd=exit
|
|
}])
|
|
|
|
# m4go_optional_file_arg(OPTION-NAME)
|
|
# -----------------------------------
|
|
# As above, but for options that optionally takes the name of an
|
|
# existing file as its argument.
|
|
m4_define([m4go_optional_file_arg],
|
|
[ if test [$]# -gt 0; then
|
|
case $optarg in # ((
|
|
-*) ;;
|
|
*) $1=$optarg
|
|
test -r "$optarg" || {
|
|
func_error "$opt: cannot read file \`$optarg'."
|
|
exit_cmd=exit
|
|
}
|
|
shift ;;
|
|
esac
|
|
fi])
|
|
|
|
|
|
# m4go_printopts
|
|
# --------------
|
|
# This macro expands to the complete command line option processing
|
|
# loop, providing for user declared options from `M4SH_GETOPTS' as well
|
|
# as support for `-x|--debug', `-\?|-h|--help' and `--version'. The
|
|
# latter two extract their output from a stylized comment at the start
|
|
# of the script, and will not work correctly if the format is not
|
|
# followed precisely.
|
|
m4_define([m4go_printopts],
|
|
[
|
|
# Option defaults:
|
|
debug_cmd=${debug_cmd-':'}
|
|
m4go_defaults
|
|
|
|
# Parse options once, thoroughly. This comes as soon as possible in the
|
|
# script to make things like `--version' happen as quickly as we can.
|
|
{
|
|
# this just eases exit handling
|
|
while test [$]# -gt 0; do
|
|
opt=[$]1
|
|
shift
|
|
case $opt in
|
|
--debug|-x) debug_cmd='set -x'
|
|
func_echo "enabling shell trace mode"
|
|
$debug_cmd
|
|
;;
|
|
m4go_branches
|
|
-\?|-h) func_usage ;;
|
|
--help) func_help ;;
|
|
--version) func_version ;;
|
|
|
|
# Separate optargs to long options:
|
|
--*=*)
|
|
func_split_long_opt "$opt"
|
|
set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"[$]@"}
|
|
shift
|
|
;;
|
|
|
|
m4_ifset([m4go_shortargs], dnl (
|
|
[ # Separate optargs to short options:
|
|
]m4go_shortargs[)
|
|
func_split_short_opt "$opt"
|
|
set dummy "$func_split_short_opt_name" "$func_split_short_opt_arg" ${1+"[$]@"}
|
|
shift
|
|
;;
|
|
|
|
])m4_ifset([m4go_shortnoargs], dnl (
|
|
[ # Separate non-argument short options:
|
|
]m4go_shortnoargs[)
|
|
func_split_short_opt "$opt"
|
|
set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"[$]@"}
|
|
shift
|
|
;;
|
|
|
|
]) --) break ;;
|
|
-*) func_fatal_help "unrecognized option \`$opt'" ;;
|
|
*) set dummy "$opt" ${1+"[$]@"}; shift; break ;;
|
|
esac
|
|
done
|
|
m4_ifset([m4go_validation],
|
|
[
|
|
# Validate options:
|
|
m4go_validation
|
|
])
|
|
# Bail if the options were screwed
|
|
$exit_cmd $EXIT_FAILURE
|
|
}
|
|
])
|
|
|
|
|
|
## ------------------------- ##
|
|
## 4. Supporting Shell Code. ##
|
|
## ------------------------- ##
|
|
|
|
# The shell functions below are expanded verbatim into the shell script
|
|
# at `m4_include([getopt.m4sh]', which are necessary for the correct
|
|
# operation of the automatic `--version' and `--help' options, among
|
|
# others.
|
|
|
|
m4_divert_pop([KILL])M4SH_VERBATIM([[
|
|
# func_version
|
|
# Echo version message to standard output and exit.
|
|
func_version ()
|
|
{
|
|
$debug_cmd
|
|
|
|
$SED -n '/(C)/!b go
|
|
:more
|
|
/\./!{
|
|
N
|
|
s/\n# / /
|
|
b more
|
|
}
|
|
:go
|
|
/^# '$PROGRAM' (GNU /,/# warranty; / {
|
|
s/^# //
|
|
s/^# *$//
|
|
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
|
|
p
|
|
}' < "$progpath"
|
|
exit $?
|
|
}
|
|
|
|
# func_usage
|
|
# Echo short help message to standard output and exit.
|
|
func_usage ()
|
|
{
|
|
$debug_cmd
|
|
|
|
$SED -n '/^# Usage:/,/^# *.*--help/ {
|
|
s/^# //
|
|
s/^# *$//
|
|
s/\$progname/'$progname'/
|
|
p
|
|
}' < "$progpath"
|
|
echo
|
|
$ECHO "run \`$progname --help | more' for full usage"
|
|
exit $?
|
|
}
|
|
|
|
# func_help [NOEXIT]
|
|
# Echo long help message to standard output and exit,
|
|
# unless 'noexit' is passed as argument.
|
|
func_help ()
|
|
{
|
|
$debug_cmd
|
|
|
|
$SED -n '/^# Usage:/,/# Report bugs to/ {
|
|
:print
|
|
s/^# //
|
|
s/^# *$//
|
|
s*\$progname*'$progname'*
|
|
s*\$host*'"$host"'*
|
|
s*\$SHELL*'"$SHELL"'*
|
|
s*\$LTCC*'"$LTCC"'*
|
|
s*\$LTCFLAGS*'"$LTCFLAGS"'*
|
|
s*\$LD*'"$LD"'*
|
|
s/\$with_gnu_ld/'"$with_gnu_ld"'/
|
|
s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
|
|
s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
|
|
p
|
|
d
|
|
}
|
|
/^# .* home page:/b print
|
|
/^# General help using/b print
|
|
' < "$progpath"
|
|
ret=$?
|
|
if test -z "$1"; then
|
|
exit $ret
|
|
fi
|
|
}
|
|
|
|
# func_missing_arg argname
|
|
# Echo program name prefixed message to standard error and set global
|
|
# exit_cmd.
|
|
func_missing_arg ()
|
|
{
|
|
$debug_cmd
|
|
|
|
func_error "missing argument for $1."
|
|
exit_cmd=exit
|
|
}
|
|
|
|
|
|
# If this shell supports prefix and suffix pattern removal, then
|
|
# use them to avoid forking. Hide the definition in an eval in case
|
|
# the shell chokes on unsupported syntax...
|
|
if test yes = "$lt_HAVE_XSI_OPS"; then
|
|
# func_split_short_opt shortopt
|
|
# Set func_split_short_opt_name and func_split_short_opt_arg shell
|
|
# variables after splitting SHORTOPT after the 2nd character.
|
|
eval 'func_split_short_opt ()
|
|
{
|
|
$debug_cmd
|
|
|
|
func_split_short_opt_arg=${1#??}
|
|
func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
|
|
}'
|
|
|
|
# func_split_long_opt longopt
|
|
# Set func_split_long_opt_name and func_split_long_opt_arg shell
|
|
# variables after splitting LONGOPT at the `=' sign.
|
|
eval 'func_split_long_opt ()
|
|
{
|
|
func_split_long_opt_name=${1%%=*}
|
|
func_split_long_opt_arg=${1#*=}
|
|
}'
|
|
else
|
|
# ...otherwise fall back to using sed.
|
|
func_split_short_opt ()
|
|
{
|
|
my_sed_short_opt='1s/^\(..\).*$/\1/;q'
|
|
my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
|
|
|
|
func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
|
|
func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
|
|
}
|
|
|
|
func_split_long_opt ()
|
|
{
|
|
my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
|
|
my_sed_long_arg='1s/^--[^=]*=//'
|
|
|
|
func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
|
|
func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
|
|
}
|
|
fi
|
|
|
|
exit_cmd=:
|
|
]])
|