--- a/source/1.0/src/shflags +++ b/source/1.0/src/shflags @@ -1,91 +1,10 @@ -# $Id$ -# vim:et:ft=sh:sts=2:sw=2 -# -# Copyright 2008 Kate Ward. All Rights Reserved. -# Released under the LGPL (GNU Lesser General Public License) -# -# shFlags -- Advanced command-line flag library for Unix shell scripts. -# http://code.google.com/p/shflags/ -# -# Author: kate.ward@forestent.com (Kate Ward) -# -# This module implements something like the google-gflags library available -# from http://code.google.com/p/google-gflags/. -# -# FLAG TYPES: This is a list of the DEFINE_*'s that you can do. All flags take -# a name, default value, help-string, and optional 'short' name (one-letter -# name). Some flags have other arguments, which are described with the flag. -# -# DEFINE_string: takes any input, and intreprets it as a string. -# -# DEFINE_boolean: typically does not take any argument: say --myflag to set -# FLAGS_myflag to true, or --nomyflag to set FLAGS_myflag to false. -# Alternately, you can say -# --myflag=true or --myflag=t or --myflag=0 or -# --myflag=false or --myflag=f or --myflag=1 -# Passing an option has the same affect as passing the option once. -# -# DEFINE_float: takes an input and intreprets it as a floating point number. As -# shell does not support floats per-se, the input is merely validated as -# being a valid floating point value. -# -# DEFINE_integer: takes an input and intreprets it as an integer. -# -# SPECIAL FLAGS: There are a few flags that have special meaning: -# --help (or -?) prints a list of all the flags in a human-readable fashion -# --flagfile=foo read flags from foo. (not implemented yet) -# -- as in getopt(), terminates flag-processing -# -# EXAMPLE USAGE: -# -# -- begin hello.sh -- -# #! /bin/sh -# . ./shflags -# DEFINE_string name 'world' "somebody's name" n -# FLAGS "$@" || exit $? -# eval set -- "${FLAGS_ARGV}" -# echo "Hello, ${FLAGS_name}." -# -- end hello.sh -- -# -# $ ./hello.sh -n Kate -# Hello, Kate. -# -# NOTE: Not all systems include a getopt version that supports long flags. On -# these systems, only short flags are recognized. - -#============================================================================== -# shFlags -# -# Shared attributes: -# flags_error: last error message -# flags_return: last return value -# -# __flags_longNames: list of long names for all flags -# __flags_shortNames: list of short names for all flags -# __flags_boolNames: list of boolean flag names -# -# __flags_opts: options parsed by getopt -# -# Per-flag attributes: -# FLAGS_: contains value of flag named 'flag_name' -# __flags__default: the default flag value -# __flags__help: the flag help string -# __flags__short: the flag short name -# __flags__type: the flag type -# -# Notes: -# - lists of strings are space separated, and a null value is the '~' char. - -# return if FLAGS already loaded [ -n "${FLAGS_VERSION:-}" ] && return 0 FLAGS_VERSION='1.0.3' -# return values FLAGS_TRUE=0 FLAGS_FALSE=1 FLAGS_ERROR=2 -# reserved flag names FLAGS_RESERVED='ARGC ARGV ERROR FALSE HELP PARENT RESERVED TRUE VERSION' _flags_debug() { echo "flags:DEBUG $@" >&2; } @@ -93,7 +12,6 @@ _flags_warn() { echo "flags:WARN $@" >&2 _flags_error() { echo "flags:ERROR $@" >&2; } _flags_fatal() { echo "flags:FATAL $@" >&2; } -# specific shell checks if [ -n "${ZSH_VERSION:-}" ]; then setopt |grep "^shwordsplit$" >/dev/null if [ $? -ne ${FLAGS_TRUE} ]; then @@ -107,20 +25,15 @@ if [ -n "${ZSH_VERSION:-}" ]; then fi fi -# -# constants -# -# getopt version __FLAGS_GETOPT_VERS_STD=0 __FLAGS_GETOPT_VERS_ENH=1 __FLAGS_GETOPT_VERS_BSD=2 getopt >/dev/null 2>&1 case $? in - 0) __FLAGS_GETOPT_VERS=${__FLAGS_GETOPT_VERS_STD} ;; # bsd getopt + 0) __FLAGS_GETOPT_VERS=${__FLAGS_GETOPT_VERS_STD} ;; 2) - # TODO(kward): look into '-T' option to test the internal getopt() version if [ "`getopt --version`" = '-- ' ]; then __FLAGS_GETOPT_VERS=${__FLAGS_GETOPT_VERS_STD} else @@ -133,82 +46,49 @@ case $? in ;; esac -# getopt optstring lengths __FLAGS_OPTSTR_SHORT=0 __FLAGS_OPTSTR_LONG=1 __FLAGS_NULL='~' -# flag info strings __FLAGS_INFO_DEFAULT='default' __FLAGS_INFO_HELP='help' __FLAGS_INFO_SHORT='short' __FLAGS_INFO_TYPE='type' -# flag lengths __FLAGS_LEN_SHORT=0 __FLAGS_LEN_LONG=1 -# flag types __FLAGS_TYPE_NONE=0 __FLAGS_TYPE_BOOLEAN=1 __FLAGS_TYPE_FLOAT=2 __FLAGS_TYPE_INTEGER=3 __FLAGS_TYPE_STRING=4 -# set the constants readonly __flags_constants=`set |awk -F= '/^FLAGS_/ || /^__FLAGS_/ {print $1}'` for __flags_const in ${__flags_constants}; do - # skip certain flags case ${__flags_const} in FLAGS_HELP) continue ;; FLAGS_PARENT) continue ;; esac - # set flag readonly if [ -z "${ZSH_VERSION:-}" ]; then readonly ${__flags_const} - else # handle zsh + else case ${ZSH_VERSION} in [123].*) readonly ${__flags_const} ;; - *) readonly -g ${__flags_const} ;; # declare readonly constants globally + *) readonly -g ${__flags_const} ;; esac fi done unset __flags_const __flags_constants -# -# internal variables -# - -__flags_boolNames=' ' # space separated list of boolean flag names -__flags_longNames=' ' # space separated list of long flag names -__flags_shortNames=' ' # space separated list of short flag names - -__flags_columns='' # screen width in columns -__flags_opts='' # temporary storage for parsed getopt flags - -#------------------------------------------------------------------------------ -# private functions -# - -# Define a flag. -# -# Calling this function will define the following info variables for the -# specified flag: -# FLAGS_flagname - the name for this flag (based upon the long flag name) -# __flags__default - the default value -# __flags_flagname_help - the help string -# __flags_flagname_short - the single letter alias -# __flags_flagname_type - the type of flag (one of __FLAGS_TYPE_*) -# -# Args: -# _flags__type: integer: internal type of flag (__FLAGS_TYPE_*) -# _flags__name: string: long flag name -# _flags__default: default flag value -# _flags__help: string: help string -# _flags__short: string: (optional) short flag name -# Returns: -# integer: success of operation, or error + +__flags_boolNames=' ' +__flags_longNames=' ' +__flags_shortNames=' ' +__flags_columns='' +__flags_opts='' + _flags_define() { if [ $# -lt 4 ]; then @@ -226,16 +106,13 @@ _flags_define() _flags_return_=${FLAGS_TRUE} - # TODO(kward): check for validity of the flag name (e.g. dashes) - # check whether the flag name is reserved echo " ${FLAGS_RESERVED} " |grep " ${_flags_name_} " >/dev/null if [ $? -eq 0 ]; then flags_error="flag name (${_flags_name_}) is reserved" _flags_return_=${FLAGS_ERROR} fi - # require short option for getopt that don't support long options if [ ${_flags_return_} -eq ${FLAGS_TRUE} \ -a ${__FLAGS_GETOPT_VERS} -ne ${__FLAGS_GETOPT_VERS_ENH} \ -a "${_flags_short_}" = "${__FLAGS_NULL}" ] @@ -244,7 +121,6 @@ _flags_define() _flags_return_=${FLAGS_ERROR} fi - # check for existing long name definition if [ ${_flags_return_} -eq ${FLAGS_TRUE} ]; then if _flags_itemInList "${_flags_name_}" \ ${__flags_longNames} ${__flags_boolNames} @@ -255,7 +131,6 @@ _flags_define() fi fi - # check for existing short name definition if [ ${_flags_return_} -eq ${FLAGS_TRUE} \ -a "${_flags_short_}" != "${__FLAGS_NULL}" ] then @@ -266,9 +141,6 @@ _flags_define() fi fi - # handle default value. note, on several occasions the 'if' portion of an - # if/then/else contains just a ':' which does nothing. a binary reversal via - # '!' is not done because it does not work on all shells. if [ ${_flags_return_} -eq ${FLAGS_TRUE} ]; then case ${_flags_type_} in ${__FLAGS_TYPE_BOOLEAN}) @@ -301,7 +173,7 @@ _flags_define() fi ;; - ${__FLAGS_TYPE_STRING}) ;; # everything in shell is a valid string + ${__FLAGS_TYPE_STRING}) ;; *) flags_error="unrecognized flag type '${_flags_type_}'" @@ -311,7 +183,6 @@ _flags_define() fi if [ ${_flags_return_} -eq ${FLAGS_TRUE} ]; then - # store flag information eval "FLAGS_${_flags_name_}='${_flags_default_}'" eval "__flags_${_flags_name_}_${__FLAGS_INFO_TYPE}=${_flags_type_}" eval "__flags_${_flags_name_}_${__FLAGS_INFO_DEFAULT}=\ @@ -319,7 +190,6 @@ _flags_define() eval "__flags_${_flags_name_}_${__FLAGS_INFO_HELP}=\"${_flags_help_}\"" eval "__flags_${_flags_name_}_${__FLAGS_INFO_SHORT}='${_flags_short_}'" - # append flag name(s) to list of names __flags_longNames="${__flags_longNames}${_flags_name_} " __flags_shortNames="${__flags_shortNames}${_flags_short_} " [ ${_flags_type_} -eq ${__FLAGS_TYPE_BOOLEAN} ] && \ @@ -333,17 +203,6 @@ _flags_define() return ${flags_return} } -# Return valid getopt options using currently defined list of long options. -# -# This function builds a proper getopt option string for short (and long) -# options, using the current list of long options for reference. -# -# Args: -# _flags_optStr: integer: option string type (__FLAGS_OPTSTR_*) -# Output: -# string: generated option string for getopt -# Returns: -# boolean: success of operation (always returns True) _flags_genOptStr() { _flags_optStrType_=$1 @@ -358,7 +217,6 @@ _flags_genOptStr() ${_flags_flag_} ${__FLAGS_INFO_SHORT}` if [ "${_flags_shortName_}" != "${__FLAGS_NULL}" ]; then _flags_opts_="${_flags_opts_}${_flags_shortName_}" - # getopt needs a trailing ':' to indicate a required argument [ ${_flags_type_} -ne ${__FLAGS_TYPE_BOOLEAN} ] && \ _flags_opts_="${_flags_opts_}:" fi @@ -366,7 +224,6 @@ _flags_genOptStr() ${__FLAGS_OPTSTR_LONG}) _flags_opts_="${_flags_opts_:+${_flags_opts_},}${_flags_flag_}" - # getopt needs a trailing ':' to indicate a required argument [ ${_flags_type_} -ne ${__FLAGS_TYPE_BOOLEAN} ] && \ _flags_opts_="${_flags_opts_}:" ;; @@ -379,15 +236,6 @@ _flags_genOptStr() return ${FLAGS_TRUE} } -# Returns flag details based on a flag name and flag info. -# -# Args: -# string: long flag name -# string: flag info (see the _flags_define function for valid info types) -# Output: -# string: value of dereferenced flag variable -# Returns: -# integer: one of FLAGS_{TRUE|FALSE|ERROR} _flags_getFlagInfo() { _flags_name_=$1 @@ -399,13 +247,6 @@ _flags_getFlagInfo() if [ -n "${_flags_value_}" ]; then flags_return=${FLAGS_TRUE} else - # see if the _flags_name_ variable is a string as strings can be empty... - # note: the DRY principle would say to have this function call itself for - # the next three lines, but doing so results in an infinite loop as an - # invalid _flags_name_ will also not have the associated _type variable. - # Because it doesn't (it will evaluate to an empty string) the logic will - # try to find the _type variable of the _type variable, and so on. Not so - # good ;-) _flags_typeVar_="__flags_${_flags_name_}_${__FLAGS_INFO_TYPE}" _flags_strToEval_="_flags_type_=\"\${${_flags_typeVar_}:-}\"" eval "${_flags_strToEval_}" @@ -424,15 +265,6 @@ _flags_getFlagInfo() return ${flags_return} } -# check for presense of item in a list. passed a string (e.g. 'abc'), this -# function will determine if the string is present in the list of strings (e.g. -# ' foo bar abc '). -# -# Args: -# _flags__str: string: string to search for in a list of strings -# unnamed: list: list of strings -# Returns: -# boolean: true if item is in the list _flags_itemInList() { _flags_str_=$1 @@ -449,34 +281,22 @@ _flags_itemInList() return ${flags_return} } -# Returns the width of the current screen. -# -# Output: -# integer: width in columns of the current screen. _flags_columns() { if [ -z "${__flags_columns}" ]; then - # determine the value and store it if eval stty size >/dev/null 2>&1; then - # stty size worked :-) set -- `stty size` __flags_columns=$2 elif eval tput cols >/dev/null 2>&1; then set -- `tput cols` __flags_columns=$1 else - __flags_columns=80 # default terminal width + __flags_columns=80 fi fi echo ${__flags_columns} } -# Validate a boolean. -# -# Args: -# _flags__bool: boolean: value to validate -# Returns: -# bool: true if the value is a valid boolean _flags_validateBoolean() { _flags_bool_=$1 @@ -492,12 +312,6 @@ _flags_validateBoolean() return ${flags_return} } -# Validate a float. -# -# Args: -# _flags__float: float: value to validate -# Returns: -# bool: true if the value is a valid float _flags_validateFloat() { _flags_float_=$1 @@ -507,10 +321,10 @@ _flags_validateFloat() else flags_return=${FLAGS_TRUE} case ${_flags_float_} in - -*) # negative floats + -*) _flags_test_=`expr "${_flags_float_}" : '\(-[0-9][0-9]*\.[0-9][0-9]*\)'` ;; - *) # positive floats + *) _flags_test_=`expr "${_flags_float_}" : '\([0-9][0-9]*\.[0-9][0-9]*\)'` ;; esac @@ -521,22 +335,16 @@ _flags_validateFloat() return ${flags_return} } -# Validate an integer. -# -# Args: -# _flags__integer: interger: value to validate -# Returns: -# bool: true if the value is a valid integer _flags_validateInteger() { _flags_int_=$1 flags_return=${FLAGS_TRUE} case ${_flags_int_} in - -*) # negative ints + -*) _flags_test_=`expr "${_flags_int_}" : '\(-[0-9][0-9]*\)'` ;; - *) # positive ints + *) _flags_test_=`expr "${_flags_int_}" : '\([0-9][0-9]*\)'` ;; esac @@ -546,23 +354,12 @@ _flags_validateInteger() return ${flags_return} } -# Parse command-line options using the standard getopt. -# -# Note: the flag options are passed around in the global __flags_opts so that -# the formatting is not lost due to shell parsing and such. -# -# Args: -# @: varies: command-line options to parse -# Returns: -# integer: a FLAGS success condition _flags_getoptStandard() { flags_return=${FLAGS_TRUE} _flags_shortOpts_=`_flags_genOptStr ${__FLAGS_OPTSTR_SHORT}` - # check for spaces in passed options for _flags_opt_ in "$@"; do - # note: the silliness with the x's is purely for ksh93 on Ubuntu 6.06 _flags_match_=`echo "x${_flags_opt_}x" |sed 's/ //g'` if [ "${_flags_match_}" != "x${_flags_opt_}x" ]; then flags_error='the available getopt does not support spaces in options' @@ -585,15 +382,6 @@ _flags_getoptStandard() return ${flags_return} } -# Parse command-line options using the enhanced getopt. -# -# Note: the flag options are passed around in the global __flags_opts so that -# the formatting is not lost due to shell parsing and such. -# -# Args: -# @: varies: command-line options to parse -# Returns: -# integer: a FLAGS success condition _flags_getoptEnhanced() { flags_return=${FLAGS_TRUE} @@ -617,17 +405,6 @@ _flags_getoptEnhanced() return ${flags_return} } -# Dynamically parse a getopt result and set appropriate variables. -# -# This function does the actual conversion of getopt output and runs it through -# the standard case structure for parsing. The case structure is actually quite -# dynamic to support any number of flags. -# -# Args: -# argc: int: original command-line argument count -# @: varies: output from getopt parsing -# Returns: -# integer: a FLAGS success condition _flags_parseGetopt() { _flags_argc_=$1 @@ -638,35 +415,26 @@ _flags_parseGetopt() if [ ${__FLAGS_GETOPT_VERS} -ne ${__FLAGS_GETOPT_VERS_ENH} ]; then set -- $@ else - # note the quotes around the `$@' -- they are essential! eval set -- "$@" fi - # provide user with number of arguments to shift by later - # NOTE: the FLAGS_ARGC variable is obsolete as of 1.0.3 because it does not - # properly give user access to non-flag arguments mixed in between flag - # arguments. Its usage was replaced by FLAGS_ARGV, and it is being kept only - # for backwards compatibility reasons. FLAGS_ARGC=`expr $# - 1 - ${_flags_argc_}` - # handle options. note options with values must do an additional shift while true; do _flags_opt_=$1 _flags_arg_=${2:-} _flags_type_=${__FLAGS_TYPE_NONE} _flags_name_='' - # determine long flag name case "${_flags_opt_}" in - --) shift; break ;; # discontinue option parsing + --) shift; break ;; - --*) # long option + --*) _flags_opt_=`expr "${_flags_opt_}" : '--\(.*\)'` _flags_len_=${__FLAGS_LEN_LONG} if _flags_itemInList "${_flags_opt_}" ${__flags_longNames}; then _flags_name_=${_flags_opt_} else - # check for negated long boolean version if _flags_itemInList "${_flags_opt_}" ${__flags_boolNames}; then _flags_name_=`expr "${_flags_opt_}" : 'no\(.*\)'` _flags_type_=${__FLAGS_TYPE_BOOLEAN} @@ -675,12 +443,10 @@ _flags_parseGetopt() fi ;; - -*) # short option + -*) _flags_opt_=`expr "${_flags_opt_}" : '-\(.*\)'` _flags_len_=${__FLAGS_LEN_SHORT} if _flags_itemInList "${_flags_opt_}" ${__flags_shortNames}; then - # yes. match short name to long name. note purposeful off-by-one - # (too high) with awk calculations. _flags_pos_=`echo "${__flags_shortNames}" \ |awk 'BEGIN{RS=" ";rn=0}$0==e{rn=NR}END{print rn}' \ e=${_flags_opt_}` @@ -690,14 +456,12 @@ _flags_parseGetopt() ;; esac - # die if the flag was unrecognized if [ -z "${_flags_name_}" ]; then flags_error="unrecognized option (${_flags_opt_})" flags_return=${FLAGS_ERROR} break fi - # set new flag value [ ${_flags_type_} -eq ${__FLAGS_TYPE_NONE} ] && \ _flags_type_=`_flags_getFlagInfo \ "${_flags_name_}" ${__FLAGS_INFO_TYPE}` @@ -746,7 +510,6 @@ _flags_parseGetopt() ;; esac - # handle special case help flag if [ "${_flags_name_}" = 'help' ]; then if [ ${FLAGS_help} -eq ${FLAGS_TRUE} ]; then flags_help @@ -756,12 +519,10 @@ _flags_parseGetopt() fi fi - # shift the option and non-boolean arguements out. shift [ ${_flags_type_} != ${__FLAGS_TYPE_BOOLEAN} ] && shift done - # give user back non-flag arguments FLAGS_ARGV='' while [ $# -gt 0 ]; do FLAGS_ARGV="${FLAGS_ARGV:+${FLAGS_ARGV} }'$1'" @@ -773,43 +534,18 @@ _flags_parseGetopt() return ${flags_return} } -#------------------------------------------------------------------------------ -# public functions -# - -# A basic boolean flag. Boolean flags do not take any arguments, and their -# value is either 1 (false) or 0 (true). For long flags, the false value is -# specified on the command line by prepending the word 'no'. With short flags, -# the presense of the flag toggles the current value between true and false. -# Specifying a short boolean flag twice on the command results in returning the -# value back to the default value. -# -# A default value is required for boolean flags. -# -# For example, lets say a Boolean flag was created whose long name was 'update' -# and whose short name was 'x', and the default value was 'false'. This flag -# could be explicitly set to 'true' with '--update' or by '-x', and it could be -# explicitly set to 'false' with '--noupdate'. + DEFINE_boolean() { _flags_define ${__FLAGS_TYPE_BOOLEAN} "$@"; } -# Other basic flags. DEFINE_float() { _flags_define ${__FLAGS_TYPE_FLOAT} "$@"; } DEFINE_integer() { _flags_define ${__FLAGS_TYPE_INTEGER} "$@"; } DEFINE_string() { _flags_define ${__FLAGS_TYPE_STRING} "$@"; } -# Parse the flags. -# -# Args: -# unnamed: list: command-line flags to parse -# Returns: -# integer: success of operation, or error FLAGS() { - # define a standard 'help' flag if one isn't already defined [ -z "${__flags_help_type:-}" ] && \ DEFINE_boolean 'help' false 'show this help' 'h' - # parse options if [ $# -gt 0 ]; then if [ ${__FLAGS_GETOPT_VERS} -ne ${__FLAGS_GETOPT_VERS_ENH} ]; then _flags_getoptStandard "$@" @@ -818,7 +554,6 @@ FLAGS() fi flags_return=$? else - # nothing passed; won't bother running getopt __flags_opts='--' flags_return=${FLAGS_TRUE} fi @@ -832,23 +567,11 @@ FLAGS() return ${flags_return} } -# This is a helper function for determining the `getopt` version for platforms -# where the detection isn't working. It simply outputs debug information that -# can be included in a bug report. -# -# Args: -# none -# Output: -# debug info that can be included in a bug report -# Returns: -# nothing flags_getoptInfo() { - # platform info _flags_debug "uname -a: `uname -a`" _flags_debug "PATH: ${PATH}" - # shell info if [ -n "${BASH_VERSION:-}" ]; then _flags_debug 'shell: bash' _flags_debug "BASH_VERSION: ${BASH_VERSION}" @@ -857,7 +580,6 @@ flags_getoptInfo() _flags_debug "ZSH_VERSION: ${ZSH_VERSION}" fi - # getopt info getopt >/dev/null _flags_getoptReturn=$? _flags_debug "getopt return: ${_flags_getoptReturn}" @@ -866,39 +588,16 @@ flags_getoptInfo() unset _flags_getoptReturn } -# Returns whether the detected getopt version is the enhanced version. -# -# Args: -# none -# Output: -# none -# Returns: -# bool: true if getopt is the enhanced version flags_getoptIsEnh() { test ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_ENH} } -# Returns whether the detected getopt version is the standard version. -# -# Args: -# none -# Returns: -# bool: true if getopt is the standard version flags_getoptIsStd() { test ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_STD} } -# This is effectively a 'usage()' function. It prints usage information and -# exits the program with ${FLAGS_FALSE} if it is ever found in the command line -# arguments. Note this function can be overridden so other apps can define -# their own --help flag, replacing this one, if they want. -# -# Args: -# none -# Returns: -# integer: success of operation (always returns true) flags_help() { if [ -n "${FLAGS_HELP:-}" ]; then @@ -953,19 +652,14 @@ flags_help() echo "${flags_helpStr_}" >&2 else echo " ${flags_flagStr_} ${flags_help_}" >&2 - # note: the silliness with the x's is purely for ksh93 on Ubuntu 6.06 - # because it doesn't like empty strings when used in this manner. flags_emptyStr_="`echo \"x${flags_flagStr_}x\" \ |awk '{printf "%"length($0)-2"s", ""}'`" flags_helpStr_=" ${flags_emptyStr_} ${flags_defaultStr_}" flags_helpStrLen_=`expr "${flags_helpStr_}" : '.*'` if [ ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_STD} \ -o ${flags_helpStrLen_} -lt ${flags_columns_} ]; then - # indented to match help string echo "${flags_helpStr_}" >&2 else - # indented four from left to allow for longer defaults as long flag - # names might be used too, making things too long echo " ${flags_defaultStr_}" >&2 fi fi @@ -978,12 +672,6 @@ flags_help() return ${FLAGS_TRUE} } -# Reset shflags back to an uninitialized state. -# -# Args: -# none -# Returns: -# nothing flags_reset() { for flags_name_ in ${__flags_longNames}; do @@ -1000,7 +688,6 @@ flags_reset() eval ${flags_strToEval_} done - # reset internal variables __flags_boolNames=' ' __flags_longNames=' ' __flags_shortNames=' '