From ccfb1cfdd04926810edbc3bf118b2cd5a2c8b673 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Fri, 6 Oct 2017 22:45:27 +0200
Subject: Moved src/* and bin/gen_test_results.* up to root.

---
 shflags | 1217 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1217 insertions(+)
 create mode 100644 shflags

(limited to 'shflags')

diff --git a/shflags b/shflags
new file mode 100644
index 0000000..470bd1f
--- /dev/null
+++ b/shflags
@@ -0,0 +1,1217 @@
+# vim:et:ft=sh:sts=2:sw=2
+#
+# Copyright 2008-2017 Kate Ward. All Rights Reserved.
+# Released under the Apache License 2.0 license.
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# shFlags -- Advanced command-line flag library for Unix shell scripts.
+# https://github.com/kward/shflags
+#
+# Author: kate.ward@forestent.com (Kate Ward)
+#
+# This module implements something like the gflags library available
+# from https://github.com/gflags/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 interprets it as a string.
+#
+# DEFINE_boolean: does not take any arguments. Say --myflag to set
+#   FLAGS_myflag to true, or --nomyflag to set FLAGS_myflag to false. For short
+#   flags, passing the flag on the command-line negates the default value, i.e.
+#   if the default is true, passing the flag sets the value to false.
+#
+# DEFINE_float: takes an input and interprets 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 interprets 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.
+#
+# CUSTOMIZABLE BEHAVIOR:
+#
+# A script can override the default 'getopt' command by providing the path to
+# an alternate implementation by defining the FLAGS_GETOPT_CMD variable.
+#
+# NOTES:
+#
+# * 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_output: last function output (rarely valid)
+#   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_<flag_name>: contains value of flag named 'flag_name'
+#   __flags_<flag_name>_default: the default flag value
+#   __flags_<flag_name>_help: the flag help string
+#   __flags_<flag_name>_short: the flag short name
+#   __flags_<flag_name>_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.2.1'
+
+# Return values that scripts can use.
+FLAGS_TRUE=0
+FLAGS_FALSE=1
+FLAGS_ERROR=2
+
+# Logging levels.
+FLAGS_LEVEL_DEBUG=0
+FLAGS_LEVEL_INFO=1
+FLAGS_LEVEL_WARN=2
+FLAGS_LEVEL_ERROR=3
+FLAGS_LEVEL_FATAL=4
+__FLAGS_LEVEL_DEFAULT=${FLAGS_LEVEL_WARN}
+
+# Determine some reasonable command defaults.
+__FLAGS_EXPR_CMD='expr --'
+__FLAGS_UNAME_S=`uname -s`
+if [ "${__FLAGS_UNAME_S}" = 'BSD' ]; then
+  __FLAGS_EXPR_CMD='gexpr --'
+else
+  _flags_output_=`${__FLAGS_EXPR_CMD} 2>&1`
+  if [ $? -eq ${FLAGS_TRUE} -a "${_flags_output_}" = '--' ]; then
+    # We are likely running inside BusyBox.
+    __FLAGS_EXPR_CMD='expr'
+  fi
+  unset _flags_output_
+fi
+
+# Commands a user can override if needed.
+FLAGS_EXPR_CMD=${FLAGS_EXPR_CMD:-${__FLAGS_EXPR_CMD}}
+FLAGS_GETOPT_CMD=${FLAGS_GETOPT_CMD:-getopt}
+
+# Specific shell checks.
+if [ -n "${ZSH_VERSION:-}" ]; then
+  setopt |grep "^shwordsplit$" >/dev/null
+  if [ $? -ne ${FLAGS_TRUE} ]; then
+    _flags_fatal 'zsh shwordsplit option is required for proper zsh operation'
+  fi
+  if [ -z "${FLAGS_PARENT:-}" ]; then
+    _flags_fatal "zsh does not pass \$0 through properly. please declare' \
+\"FLAGS_PARENT=\$0\" before calling shFlags"
+  fi
+fi
+
+# Can we use built-ins?
+( echo "${FLAGS_TRUE#0}"; ) >/dev/null 2>&1
+if [ $? -eq ${FLAGS_TRUE} ]; then
+  __FLAGS_USE_BUILTIN=${FLAGS_TRUE}
+else
+  __FLAGS_USE_BUILTIN=${FLAGS_FALSE}
+fi
+
+
+#
+# Constants.
+#
+
+# Reserved flag names.
+__FLAGS_RESERVED_LIST=' ARGC ARGV ERROR FALSE GETOPT_CMD HELP PARENT TRUE '
+__FLAGS_RESERVED_LIST="${__FLAGS_RESERVED_LIST} VERSION "
+
+# getopt version.
+__FLAGS_GETOPT_VERS_STD=0
+__FLAGS_GETOPT_VERS_ENH=1
+__FLAGS_GETOPT_VERS_BSD=2
+
+${FLAGS_GETOPT_CMD} >/dev/null 2>&1
+case $? in
+  0) __FLAGS_GETOPT_VERS=${__FLAGS_GETOPT_VERS_STD} ;;  # bsd getopt
+  1) __FLAGS_GETOPT_VERS=${__FLAGS_GETOPT_VERS_ENH} ;;  # BusyBox getopt.
+  2)
+    # TODO(kward): look into '-T' option to test the internal getopt() version
+    if [ "`${FLAGS_GETOPT_CMD} --version`" = '-- ' ]; then
+      __FLAGS_GETOPT_VERS=${__FLAGS_GETOPT_VERS_STD}
+    else
+      __FLAGS_GETOPT_VERS=${__FLAGS_GETOPT_VERS_ENH}
+    fi
+    ;;
+  *) _flags_fatal 'unable to determine getopt version' ;;
+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}
+    continue
+  fi
+  case ${ZSH_VERSION} in
+    [123].*) readonly ${__flags_const} ;;
+    *) readonly -g ${__flags_const} ;;  # Declare readonly constants globally.
+  esac
+done
+unset __flags_const __flags_constants
+
+#
+# Internal variables.
+#
+
+# Space separated lists.
+__flags_boolNames=' '     # Boolean flag names.
+__flags_longNames=' '     # Long flag names.
+__flags_shortNames=' '    # Short flag names.
+__flags_definedNames=' '  # Defined flag names (used for validation).
+
+__flags_columns=''  # Screen width in columns.
+__flags_level=0     # Default logging level.
+__flags_opts=''     # Temporary storage for parsed getopt flags.
+
+#------------------------------------------------------------------------------
+# Private functions.
+#
+
+# Logging functions.
+_flags_debug() {
+  [ ${__flags_level} -le ${FLAGS_LEVEL_DEBUG} ] || return
+  echo "flags:DEBUG $@" >&2
+}
+_flags_info() {
+  [ ${__flags_level} -le ${FLAGS_LEVEL_INFO} ] || return
+  echo "flags:INFO $@" >&2
+}
+_flags_warn() {
+  [ ${__flags_level} -le ${FLAGS_LEVEL_WARN} ] || return
+  echo "flags:WARN $@" >&2
+}
+_flags_error() {
+  [ ${__flags_level} -le ${FLAGS_LEVEL_ERROR} ] || return
+  echo "flags:ERROR $@" >&2
+}
+_flags_fatal() {
+  [ ${__flags_level} -le ${FLAGS_LEVEL_FATAL} ] || return
+  echo "flags:FATAL $@" >&2
+  exit ${FLAGS_ERROR}
+}
+
+# Get the logging level.
+flags_loggingLevel() { echo ${__flags_level}; }
+
+# Set the logging level.
+#
+# Args:
+#   _flags_level_: integer: new logging level
+# Returns:
+#   nothing
+flags_setLoggingLevel() {
+  [ $# -ne 1 ] && _flags_fatal "flags_setLevel(): logging level missing"
+  _flags_level_=$1
+  [ ${_flags_level_} -ge ${FLAGS_LEVEL_DEBUG} \
+    -a ${_flags_level_} -le ${FLAGS_LEVEL_FATAL} ] \
+      || _flags_fatal "Invalid logging level '${_flags_level_}' specified."
+  __flags_level=$1
+  unset _flags_level_
+}
+
+# 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_<flag_name>_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_define()
+{
+  if [ $# -lt 4 ]; then
+    flags_error='DEFINE error: too few arguments'
+    flags_return=${FLAGS_ERROR}
+    _flags_error "${flags_error}"
+    return ${flags_return}
+  fi
+
+  _flags_type_=$1
+  _flags_name_=$2
+  _flags_default_=$3
+  _flags_help_=$4
+  _flags_short_=${5:-${__FLAGS_NULL}}
+
+  _flags_debug "type:${_flags_type_} name:${_flags_name_}" \
+      "default:'${_flags_default_}' help:'${_flags_help_}'" \
+      "short:${_flags_short_}"
+
+  _flags_return_=${FLAGS_TRUE}
+  _flags_usName_=`_flags_underscoreName ${_flags_name_}`
+
+  # check whether the flag name is reserved
+  _flags_itemInList ${_flags_usName_} "${__FLAGS_RESERVED_LIST}"
+  if [ $? -eq ${FLAGS_TRUE} ]; 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}" ]
+  then
+    flags_error="short flag required for (${_flags_name_}) on this platform"
+    _flags_return_=${FLAGS_ERROR}
+  fi
+
+  # check for existing long name definition
+  if [ ${_flags_return_} -eq ${FLAGS_TRUE} ]; then
+    if _flags_itemInList ${_flags_usName_} ${__flags_definedNames}; then
+      flags_error="definition for ([no]${_flags_name_}) already exists"
+      _flags_warn "${flags_error}"
+      _flags_return_=${FLAGS_FALSE}
+    fi
+  fi
+
+  # check for existing short name definition
+  if [ ${_flags_return_} -eq ${FLAGS_TRUE} \
+      -a "${_flags_short_}" != "${__FLAGS_NULL}" ]
+  then
+    if _flags_itemInList "${_flags_short_}" ${__flags_shortNames}; then
+      flags_error="flag short name (${_flags_short_}) already defined"
+      _flags_warn "${flags_error}"
+      _flags_return_=${FLAGS_FALSE}
+    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})
+        if _flags_validBool "${_flags_default_}"; then
+          case ${_flags_default_} in
+            true|t|0) _flags_default_=${FLAGS_TRUE} ;;
+            false|f|1) _flags_default_=${FLAGS_FALSE} ;;
+          esac
+        else
+          flags_error="invalid default flag value '${_flags_default_}'"
+          _flags_return_=${FLAGS_ERROR}
+        fi
+        ;;
+
+      ${__FLAGS_TYPE_FLOAT})
+        if _flags_validFloat "${_flags_default_}"; then
+          :
+        else
+          flags_error="invalid default flag value '${_flags_default_}'"
+          _flags_return_=${FLAGS_ERROR}
+        fi
+        ;;
+
+      ${__FLAGS_TYPE_INTEGER})
+        if _flags_validInt "${_flags_default_}"; then
+          :
+        else
+          flags_error="invalid default flag value '${_flags_default_}'"
+          _flags_return_=${FLAGS_ERROR}
+        fi
+        ;;
+
+      ${__FLAGS_TYPE_STRING}) ;;  # everything in shell is a valid string
+
+      *)
+        flags_error="unrecognized flag type '${_flags_type_}'"
+        _flags_return_=${FLAGS_ERROR}
+        ;;
+    esac
+  fi
+
+  if [ ${_flags_return_} -eq ${FLAGS_TRUE} ]; then
+    # Store flag information.
+    eval "FLAGS_${_flags_usName_}='${_flags_default_}'"
+    eval "__flags_${_flags_usName_}_${__FLAGS_INFO_TYPE}=${_flags_type_}"
+    eval "__flags_${_flags_usName_}_${__FLAGS_INFO_DEFAULT}=\
+\"${_flags_default_}\""
+    eval "__flags_${_flags_usName_}_${__FLAGS_INFO_HELP}=\"${_flags_help_}\""
+    eval "__flags_${_flags_usName_}_${__FLAGS_INFO_SHORT}='${_flags_short_}'"
+
+    # append flag names to name lists
+    __flags_shortNames="${__flags_shortNames}${_flags_short_} "
+    __flags_longNames="${__flags_longNames}${_flags_name_} "
+    [ ${_flags_type_} -eq ${__FLAGS_TYPE_BOOLEAN} ] && \
+        __flags_boolNames="${__flags_boolNames}no${_flags_name_} "
+
+    # append flag names to defined names for later validation checks
+    __flags_definedNames="${__flags_definedNames}${_flags_usName_} "
+    [ ${_flags_type_} -eq ${__FLAGS_TYPE_BOOLEAN} ] && \
+        __flags_definedNames="${__flags_definedNames}no${_flags_usName_} "
+  fi
+
+  flags_return=${_flags_return_}
+  unset _flags_default_ _flags_help_ _flags_name_ _flags_return_ \
+      _flags_short_ _flags_type_ _flags_usName_
+  [ ${flags_return} -eq ${FLAGS_ERROR} ] && _flags_error "${flags_error}"
+  return ${flags_return}
+}
+
+# Underscore a flag name by replacing dashes with underscores.
+#
+# Args:
+#   unnamed: string: log flag name
+# Output:
+#   string: underscored name
+_flags_underscoreName()
+{
+  echo $1 |tr '-' '_'
+}
+
+# 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
+
+  _flags_opts_=''
+
+  for _flags_name_ in ${__flags_longNames}; do
+    _flags_usName_=`_flags_underscoreName ${_flags_name_}`
+    _flags_type_=`_flags_getFlagInfo ${_flags_usName_} ${__FLAGS_INFO_TYPE}`
+    [ $? -eq ${FLAGS_TRUE} ] || _flags_fatal 'call to _flags_type_ failed'
+    case ${_flags_optStrType_} in
+      ${__FLAGS_OPTSTR_SHORT})
+        _flags_shortName_=`_flags_getFlagInfo \
+            ${_flags_usName_} ${__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
+        ;;
+
+      ${__FLAGS_OPTSTR_LONG})
+        _flags_opts_="${_flags_opts_:+${_flags_opts_},}${_flags_name_}"
+        # getopt needs a trailing ':' to indicate a required argument
+        [ ${_flags_type_} -ne ${__FLAGS_TYPE_BOOLEAN} ] && \
+            _flags_opts_="${_flags_opts_}:"
+        ;;
+    esac
+  done
+
+  echo "${_flags_opts_}"
+  unset _flags_name_ _flags_opts_ _flags_optStrType_ _flags_shortName_ \
+      _flags_type_ _flags_usName_
+  return ${FLAGS_TRUE}
+}
+
+# Returns flag details based on a flag name and flag info.
+#
+# Args:
+#   string: underscored 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()
+{
+  # note: adding gFI to variable names to prevent naming conflicts with calling
+  # functions
+  _flags_gFI_usName_=$1
+  _flags_gFI_info_=$2
+
+  _flags_infoVar_="__flags_${_flags_gFI_usName_}_${_flags_gFI_info_}"
+  _flags_strToEval_="_flags_infoValue_=\"\${${_flags_infoVar_}:-}\""
+  eval "${_flags_strToEval_}"
+  if [ -n "${_flags_infoValue_+x}" ]; then
+    flags_return=${FLAGS_TRUE}
+  else
+    # see if the _flags_gFI_usName_ 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_gFI_usName_}_${__FLAGS_INFO_TYPE}"
+    _flags_strToEval_="_flags_typeValue_=\"\${${_flags_typeVar_}:-}\""
+    eval "${_flags_strToEval_}"
+    if [ "${_flags_typeValue_}" = "${__FLAGS_TYPE_STRING}" ]; then
+      flags_return=${FLAGS_TRUE}
+    else
+      flags_return=${FLAGS_ERROR}
+      flags_error="missing flag info variable (${_flags_infoVar_})"
+    fi
+  fi
+
+  echo "${_flags_infoValue_}"
+  unset _flags_gFI_usName_ _flags_gfI_info_ _flags_infoValue_ _flags_infoVar_ \
+      _flags_strToEval_ _flags_typeValue_ _flags_typeVar_
+  [ ${flags_return} -eq ${FLAGS_ERROR} ] && _flags_error "${flags_error}"
+  return ${flags_return}
+}
+
+# Check for presence 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
+  shift
+
+  case " ${*:-} " in
+    *\ ${_flags_str_}\ *) flags_return=${FLAGS_TRUE} ;;
+    *) flags_return=${FLAGS_FALSE} ;;
+  esac
+
+  unset _flags_str_
+  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
+    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_validBool()
+{
+  _flags_bool_=$1
+
+  flags_return=${FLAGS_TRUE}
+  case "${_flags_bool_}" in
+    true|t|0) ;;
+    false|f|1) ;;
+    *) flags_return=${FLAGS_FALSE} ;;
+  esac
+
+  unset _flags_bool_
+  return ${flags_return}
+}
+
+# Validate a float.
+#
+# Args:
+#   _flags_float_: float: value to validate
+# Returns:
+#   bool: true if the value is a valid integer
+_flags_validFloat() {
+  flags_return=${FLAGS_FALSE}
+  [ -n "$1" ] || return ${flags_return}
+  _flags_float_=$1
+
+  if _flags_validInt ${_flags_float_}; then
+    flags_return=${FLAGS_TRUE}
+  elif _flags_useBuiltin; then
+    _flags_float_whole_=${_flags_float_%.*}
+    _flags_float_fraction_=${_flags_float_#*.}
+    if _flags_validInt ${_flags_float_whole_:-0} -a \
+      _flags_validInt ${_flags_float_fraction_}; then
+      flags_return=${FLAGS_TRUE}
+    fi
+    unset _flags_float_whole_ _flags_float_fraction_
+  else
+    flags_return=${FLAGS_TRUE}
+    case ${_flags_float_} in
+      -*)  # negative floats
+        _flags_test_=`${FLAGS_EXPR_CMD} "${_flags_float_}" :\
+            '\(-[0-9]*\.[0-9]*\)'`
+        ;;
+      *)  # positive floats
+        _flags_test_=`${FLAGS_EXPR_CMD} "${_flags_float_}" :\
+            '\([0-9]*\.[0-9]*\)'`
+        ;;
+    esac
+    [ "${_flags_test_}" != "${_flags_float_}" ] && flags_return=${FLAGS_FALSE}
+    unset _flags_test_
+  fi
+
+  unset _flags_float_ _flags_float_whole_ _flags_float_fraction_
+  return ${flags_return}
+}
+
+# Validate an integer.
+#
+# Args:
+#   _flags_int_: integer: value to validate
+# Returns:
+#   bool: true if the value is a valid integer
+_flags_validInt()
+{
+  flags_return=${FLAGS_FALSE}
+  [ -n "$1" ] || return ${flags_return}
+  _flags_int_=$1
+
+  case ${_flags_int_} in
+    -*.*) ;;  # ignore negative floats (we'll invalidate them later)
+    -*)  # strip possible leading negative sign
+      if _flags_useBuiltin; then
+        _flags_int_=${_flags_int_#-}
+      else
+        _flags_int_=`${FLAGS_EXPR_CMD} "${_flags_int_}" : '-\([0-9][0-9]*\)'`
+      fi
+      ;;
+  esac
+
+  case ${_flags_int_} in
+    *[!0-9]*) flags_return=${FLAGS_FALSE} ;;
+    *) flags_return=${FLAGS_TRUE} ;;
+  esac
+
+  unset _flags_int_
+  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'
+      flags_return=${FLAGS_ERROR}
+      break
+    fi
+  done
+
+  if [ ${flags_return} -eq ${FLAGS_TRUE} ]; then
+    __flags_opts=`getopt ${_flags_shortOpts_} $@ 2>&1`
+    _flags_rtrn_=$?
+    if [ ${_flags_rtrn_} -ne ${FLAGS_TRUE} ]; then
+      _flags_warn "${__flags_opts}"
+      flags_error='unable to parse provided options with getopt.'
+      flags_return=${FLAGS_ERROR}
+    fi
+  fi
+
+  unset _flags_match_ _flags_opt_ _flags_rtrn_ _flags_shortOpts_
+  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}
+  _flags_shortOpts_=`_flags_genOptStr ${__FLAGS_OPTSTR_SHORT}`
+  _flags_boolOpts_=`echo "${__flags_boolNames}" \
+      |sed 's/^ *//;s/ *$//;s/ /,/g'`
+  _flags_longOpts_=`_flags_genOptStr ${__FLAGS_OPTSTR_LONG}`
+
+  __flags_opts=`${FLAGS_GETOPT_CMD} \
+      -o ${_flags_shortOpts_} \
+      -l "${_flags_longOpts_},${_flags_boolOpts_}" \
+      -- "$@" 2>&1`
+  _flags_rtrn_=$?
+  if [ ${_flags_rtrn_} -ne ${FLAGS_TRUE} ]; then
+    _flags_warn "${__flags_opts}"
+    flags_error='unable to parse provided options with getopt.'
+    flags_return=${FLAGS_ERROR}
+  fi
+
+  unset _flags_boolOpts_ _flags_longOpts_ _flags_rtrn_ _flags_shortOpts_
+  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
+  shift
+
+  flags_return=${FLAGS_TRUE}
+
+  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 the 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=`_flags_math "$# - 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
+
+      --*)  # long option
+        if _flags_useBuiltin; then
+          _flags_opt_=${_flags_opt_#*--}
+        else
+          _flags_opt_=`${FLAGS_EXPR_CMD} "${_flags_opt_}" : '--\(.*\)'`
+        fi
+        _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
+            if _flags_useBuiltin; then
+              _flags_name_=${_flags_opt_#*no}
+            else
+              _flags_name_=`${FLAGS_EXPR_CMD} "${_flags_opt_}" : 'no\(.*\)'`
+            fi
+            _flags_type_=${__FLAGS_TYPE_BOOLEAN}
+            _flags_arg_=${__FLAGS_NULL}
+          fi
+        fi
+        ;;
+
+      -*)  # short option
+        if _flags_useBuiltin; then
+          _flags_opt_=${_flags_opt_#*-}
+        else
+          _flags_opt_=`${FLAGS_EXPR_CMD} "${_flags_opt_}" : '-\(.*\)'`
+        fi
+        _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_}`
+          _flags_name_=`echo "${__flags_longNames}" \
+              |awk 'BEGIN{RS=" "}rn==NR{print $0}' rn="${_flags_pos_}"`
+        fi
+        ;;
+    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_usName_=`_flags_underscoreName ${_flags_name_}`
+    [ ${_flags_type_} -eq ${__FLAGS_TYPE_NONE} ] && \
+        _flags_type_=`_flags_getFlagInfo \
+            "${_flags_usName_}" ${__FLAGS_INFO_TYPE}`
+    case ${_flags_type_} in
+      ${__FLAGS_TYPE_BOOLEAN})
+        if [ ${_flags_len_} -eq ${__FLAGS_LEN_LONG} ]; then
+          if [ "${_flags_arg_}" != "${__FLAGS_NULL}" ]; then
+            eval "FLAGS_${_flags_usName_}=${FLAGS_TRUE}"
+          else
+            eval "FLAGS_${_flags_usName_}=${FLAGS_FALSE}"
+          fi
+        else
+          _flags_strToEval_="_flags_val_=\
+\${__flags_${_flags_usName_}_${__FLAGS_INFO_DEFAULT}}"
+          eval "${_flags_strToEval_}"
+          if [ ${_flags_val_} -eq ${FLAGS_FALSE} ]; then
+            eval "FLAGS_${_flags_usName_}=${FLAGS_TRUE}"
+          else
+            eval "FLAGS_${_flags_usName_}=${FLAGS_FALSE}"
+          fi
+        fi
+        ;;
+
+      ${__FLAGS_TYPE_FLOAT})
+        if _flags_validFloat "${_flags_arg_}"; then
+          eval "FLAGS_${_flags_usName_}='${_flags_arg_}'"
+        else
+          flags_error="invalid float value (${_flags_arg_})"
+          flags_return=${FLAGS_ERROR}
+          break
+        fi
+        ;;
+
+      ${__FLAGS_TYPE_INTEGER})
+        if _flags_validInt "${_flags_arg_}"; then
+          eval "FLAGS_${_flags_usName_}='${_flags_arg_}'"
+        else
+          flags_error="invalid integer value (${_flags_arg_})"
+          flags_return=${FLAGS_ERROR}
+          break
+        fi
+        ;;
+
+      ${__FLAGS_TYPE_STRING})
+        eval "FLAGS_${_flags_usName_}='${_flags_arg_}'"
+        ;;
+    esac
+
+    # handle special case help flag
+    if [ "${_flags_usName_}" = 'help' ]; then
+      if [ ${FLAGS_help} -eq ${FLAGS_TRUE} ]; then
+        flags_help
+        flags_error='help requested'
+        flags_return=${FLAGS_FALSE}
+        break
+      fi
+    fi
+
+    # shift the option and non-boolean arguments 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'"
+    shift
+  done
+
+  unset _flags_arg_ _flags_len_ _flags_name_ _flags_opt_ _flags_pos_ \
+      _flags_strToEval_ _flags_type_ _flags_usName_ _flags_val_
+  return ${flags_return}
+}
+
+# Perform some path using built-ins.
+#
+# Args:
+#   $@: string: math expression to evaluate
+# Output:
+#   integer: the result
+# Returns:
+#   bool: success of math evaluation
+_flags_math() {
+  if [ $# -eq 0 ]; then
+    flags_return=${FLAGS_FALSE}
+  elif _flags_useBuiltin; then
+    # Variable assignment is needed as workaround for Solaris Bourne shell,
+    # which cannot parse a bare $((expression)).
+    _flags_expr_='$(($@))'
+    eval echo ${_flags_expr_}
+    flags_return=$?
+    unset _flags_expr_
+  else
+    eval expr $@
+    flags_return=$?
+  fi
+
+  return ${flags_return}
+}
+
+# Cross-platform strlen() implementation.
+#
+# Args:
+#   _flags_str: string: to determine length of
+# Output:
+#   integer: length of string
+# Returns:
+#   bool: success of strlen evaluation
+_flags_strlen()
+{
+  _flags_str_=${1:-}
+
+  if [ -z "${_flags_str_}" ]; then
+    flags_output=0
+  elif _flags_useBuiltin; then
+    flags_output=${#_flags_str_}
+  else
+    flags_output=`${FLAGS_EXPR_CMD} "${_flags_str_}" : '.*'`
+  fi
+  flags_return=$?
+
+  unset _flags_str_
+  echo ${flags_output}
+  return ${flags_return}
+}
+
+# Use built-in helper function to enable unit testing.
+#
+# Args:
+#   None
+# Returns:
+#   bool: true if built-ins should be used
+_flags_useBuiltin() { return ${__FLAGS_USE_BUILTIN}; }
+
+#------------------------------------------------------------------------------
+# 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 presence 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 "$@"
+    else
+      _flags_getoptEnhanced "$@"
+    fi
+    flags_return=$?
+  else
+    # nothing passed; won't bother running getopt
+    __flags_opts='--'
+    flags_return=${FLAGS_TRUE}
+  fi
+
+  if [ ${flags_return} -eq ${FLAGS_TRUE} ]; then
+    _flags_parseGetopt $# "${__flags_opts}"
+    flags_return=$?
+  fi
+
+  [ ${flags_return} -eq ${FLAGS_ERROR} ] && _flags_fatal "${flags_error}"
+  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}"
+  elif [ -n "${ZSH_VERSION:-}" ]; then
+    _flags_debug 'shell: zsh'
+    _flags_debug "ZSH_VERSION: ${ZSH_VERSION}"
+  fi
+
+  # getopt info
+  ${FLAGS_GETOPT_CMD} >/dev/null
+  _flags_getoptReturn=$?
+  _flags_debug "getopt return: ${_flags_getoptReturn}"
+  _flags_debug "getopt --version: `${FLAGS_GETOPT_CMD} --version 2>&1`"
+
+  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
+    echo "${FLAGS_HELP}" >&2
+  else
+    echo "USAGE: ${FLAGS_PARENT:-$0} [flags] args" >&2
+  fi
+  if [ -n "${__flags_longNames}" ]; then
+    echo 'flags:' >&2
+    for flags_name_ in ${__flags_longNames}; do
+      flags_flagStr_=''
+      flags_boolStr_=''
+      flags_usName_=`_flags_underscoreName ${flags_name_}`
+
+      flags_default_=`_flags_getFlagInfo \
+          "${flags_usName_}" ${__FLAGS_INFO_DEFAULT}`
+      flags_help_=`_flags_getFlagInfo \
+          "${flags_usName_}" ${__FLAGS_INFO_HELP}`
+      flags_short_=`_flags_getFlagInfo \
+          "${flags_usName_}" ${__FLAGS_INFO_SHORT}`
+      flags_type_=`_flags_getFlagInfo \
+          "${flags_usName_}" ${__FLAGS_INFO_TYPE}`
+
+      [ "${flags_short_}" != "${__FLAGS_NULL}" ] && \
+          flags_flagStr_="-${flags_short_}"
+
+      if [ ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_ENH} ]; then
+        [ "${flags_short_}" != "${__FLAGS_NULL}" ] && \
+            flags_flagStr_="${flags_flagStr_},"
+        # add [no] to long boolean flag names, except the 'help' flag
+        [ ${flags_type_} -eq ${__FLAGS_TYPE_BOOLEAN} \
+          -a "${flags_usName_}" != 'help' ] && \
+            flags_boolStr_='[no]'
+        flags_flagStr_="${flags_flagStr_}--${flags_boolStr_}${flags_name_}:"
+      fi
+
+      case ${flags_type_} in
+        ${__FLAGS_TYPE_BOOLEAN})
+          if [ ${flags_default_} -eq ${FLAGS_TRUE} ]; then
+            flags_defaultStr_='true'
+          else
+            flags_defaultStr_='false'
+          fi
+          ;;
+        ${__FLAGS_TYPE_FLOAT}|${__FLAGS_TYPE_INTEGER})
+          flags_defaultStr_=${flags_default_} ;;
+        ${__FLAGS_TYPE_STRING}) flags_defaultStr_="'${flags_default_}'" ;;
+      esac
+      flags_defaultStr_="(default: ${flags_defaultStr_})"
+
+      flags_helpStr_="  ${flags_flagStr_}  ${flags_help_} ${flags_defaultStr_}"
+      _flags_strlen "${flags_helpStr_}" >/dev/null
+      flags_helpStrLen_=${flags_output}
+      flags_columns_=`_flags_columns`
+
+      if [ ${flags_helpStrLen_} -lt ${flags_columns_} ]; then
+        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_strlen "${flags_helpStr_}" >/dev/null
+        flags_helpStrLen_=${flags_output}
+
+        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
+    done
+  fi
+
+  unset flags_boolStr_ flags_default_ flags_defaultStr_ flags_emptyStr_ \
+      flags_flagStr_ flags_help_ flags_helpStr flags_helpStrLen flags_name_ \
+      flags_columns_ flags_short_ flags_type_ flags_usName_
+  return ${FLAGS_TRUE}
+}
+
+# Reset shflags back to an uninitialized state.
+#
+# Args:
+#   none
+# Returns:
+#   nothing
+flags_reset()
+{
+  for flags_name_ in ${__flags_longNames}; do
+    flags_usName_=`_flags_underscoreName ${flags_name_}`
+    flags_strToEval_="unset FLAGS_${flags_usName_}"
+    for flags_type_ in \
+        ${__FLAGS_INFO_DEFAULT} \
+        ${__FLAGS_INFO_HELP} \
+        ${__FLAGS_INFO_SHORT} \
+        ${__FLAGS_INFO_TYPE}
+    do
+      flags_strToEval_=\
+"${flags_strToEval_} __flags_${flags_usName_}_${flags_type_}"
+    done
+    eval ${flags_strToEval_}
+  done
+
+  # Reset internal variables.
+  __flags_boolNames=' '
+  __flags_longNames=' '
+  __flags_shortNames=' '
+  __flags_definedNames=' '
+
+  # Reset logging level back to default.
+  flags_setLoggingLevel ${__FLAGS_LEVEL_DEFAULT}
+
+  unset flags_name_ flags_type_ flags_strToEval_ flags_usName_
+}
+
+#
+# Initialization
+#
+
+# Set the default logging level.
+flags_setLoggingLevel ${__FLAGS_LEVEL_DEFAULT}
-- 
cgit v1.2.3


From 83807eb55add091df5890a0ff9f7d5e0bdc918d8 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Fri, 6 Oct 2017 23:22:27 +0200
Subject: Started running through ShellCheck.

---
 shflags | 52 ++++++++++++++++++++++++++++------------------------
 1 file changed, 28 insertions(+), 24 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 470bd1f..b047f27 100644
--- a/shflags
+++ b/shflags
@@ -81,6 +81,11 @@
 #
 # Notes:
 # - lists of strings are space separated, and a null value is the '~' char.
+#
+# $() are not fully portable (POSIX != portable).
+#   shellcheck disable=SC2006
+# [ p -a q ] are well defined enough (vs [ p ] && [ q ]).
+#   shellcheck disable=SC2166
 
 # Return if FLAGS already loaded.
 [ -n "${FLAGS_VERSION:-}" ] && return 0
@@ -149,7 +154,6 @@ __FLAGS_RESERVED_LIST="${__FLAGS_RESERVED_LIST} VERSION "
 # getopt version.
 __FLAGS_GETOPT_VERS_STD=0
 __FLAGS_GETOPT_VERS_ENH=1
-__FLAGS_GETOPT_VERS_BSD=2
 
 ${FLAGS_GETOPT_CMD} >/dev/null 2>&1
 case $? in
@@ -199,12 +203,12 @@ for __flags_const in ${__flags_constants}; do
   esac
   # Set flag readonly.
   if [ -z "${ZSH_VERSION:-}" ]; then
-    readonly ${__flags_const}
+    readonly "${__flags_const}"
     continue
   fi
   case ${ZSH_VERSION} in
-    [123].*) readonly ${__flags_const} ;;
-    *) readonly -g ${__flags_const} ;;  # Declare readonly constants globally.
+    [123].*) readonly "${__flags_const}" ;;
+    *) readonly -g "${__flags_const}" ;;  # Declare readonly constants globally.
   esac
 done
 unset __flags_const __flags_constants
@@ -230,23 +234,23 @@ __flags_opts=''     # Temporary storage for parsed getopt flags.
 # Logging functions.
 _flags_debug() {
   [ ${__flags_level} -le ${FLAGS_LEVEL_DEBUG} ] || return
-  echo "flags:DEBUG $@" >&2
+  echo "flags:DEBUG $*" >&2
 }
 _flags_info() {
   [ ${__flags_level} -le ${FLAGS_LEVEL_INFO} ] || return
-  echo "flags:INFO $@" >&2
+  echo "flags:INFO $*" >&2
 }
 _flags_warn() {
   [ ${__flags_level} -le ${FLAGS_LEVEL_WARN} ] || return
-  echo "flags:WARN $@" >&2
+  echo "flags:WARN $*" >&2
 }
 _flags_error() {
   [ ${__flags_level} -le ${FLAGS_LEVEL_ERROR} ] || return
-  echo "flags:ERROR $@" >&2
+  echo "flags:ERROR $*" >&2
 }
 _flags_fatal() {
   [ ${__flags_level} -le ${FLAGS_LEVEL_FATAL} ] || return
-  echo "flags:FATAL $@" >&2
+  echo "flags:FATAL $*" >&2
   exit ${FLAGS_ERROR}
 }
 
@@ -262,8 +266,8 @@ flags_loggingLevel() { echo ${__flags_level}; }
 flags_setLoggingLevel() {
   [ $# -ne 1 ] && _flags_fatal "flags_setLevel(): logging level missing"
   _flags_level_=$1
-  [ ${_flags_level_} -ge ${FLAGS_LEVEL_DEBUG} \
-    -a ${_flags_level_} -le ${FLAGS_LEVEL_FATAL} ] \
+  [ "${_flags_level_}" -ge "${FLAGS_LEVEL_DEBUG}" \
+    -a "${_flags_level_}" -le "${FLAGS_LEVEL_FATAL}" ] \
       || _flags_fatal "Invalid logging level '${_flags_level_}' specified."
   __flags_level=$1
   unset _flags_level_
@@ -307,10 +311,10 @@ _flags_define()
       "short:${_flags_short_}"
 
   _flags_return_=${FLAGS_TRUE}
-  _flags_usName_=`_flags_underscoreName ${_flags_name_}`
+  _flags_usName_="`_flags_underscoreName "${_flags_name_}"`"
 
   # check whether the flag name is reserved
-  _flags_itemInList ${_flags_usName_} "${__FLAGS_RESERVED_LIST}"
+  _flags_itemInList "${_flags_usName_}" "${__FLAGS_RESERVED_LIST}"
   if [ $? -eq ${FLAGS_TRUE} ]; then
     flags_error="flag name (${_flags_name_}) is reserved"
     _flags_return_=${FLAGS_ERROR}
@@ -327,7 +331,7 @@ _flags_define()
 
   # check for existing long name definition
   if [ ${_flags_return_} -eq ${FLAGS_TRUE} ]; then
-    if _flags_itemInList ${_flags_usName_} ${__flags_definedNames}; then
+    if _flags_itemInList "${_flags_usName_}" "${__flags_definedNames}"; then
       flags_error="definition for ([no]${_flags_name_}) already exists"
       _flags_warn "${flags_error}"
       _flags_return_=${FLAGS_FALSE}
@@ -338,7 +342,7 @@ _flags_define()
   if [ ${_flags_return_} -eq ${FLAGS_TRUE} \
       -a "${_flags_short_}" != "${__FLAGS_NULL}" ]
   then
-    if _flags_itemInList "${_flags_short_}" ${__flags_shortNames}; then
+    if _flags_itemInList "${_flags_short_}" "${__flags_shortNames}"; then
       flags_error="flag short name (${_flags_short_}) already defined"
       _flags_warn "${flags_error}"
       _flags_return_=${FLAGS_FALSE}
@@ -401,12 +405,12 @@ _flags_define()
     # append flag names to name lists
     __flags_shortNames="${__flags_shortNames}${_flags_short_} "
     __flags_longNames="${__flags_longNames}${_flags_name_} "
-    [ ${_flags_type_} -eq ${__FLAGS_TYPE_BOOLEAN} ] && \
+    [ "${_flags_type_}" -eq "${__FLAGS_TYPE_BOOLEAN}" ] && \
         __flags_boolNames="${__flags_boolNames}no${_flags_name_} "
 
     # append flag names to defined names for later validation checks
     __flags_definedNames="${__flags_definedNames}${_flags_usName_} "
-    [ ${_flags_type_} -eq ${__FLAGS_TYPE_BOOLEAN} ] && \
+    [ "${_flags_type_}" -eq "${__FLAGS_TYPE_BOOLEAN}" ] && \
         __flags_definedNames="${__flags_definedNames}no${_flags_usName_} "
   fi
 
@@ -425,7 +429,7 @@ _flags_define()
 #   string: underscored name
 _flags_underscoreName()
 {
-  echo $1 |tr '-' '_'
+  echo "$1" |tr '-' '_'
 }
 
 # Return valid getopt options using currently defined list of long options.
@@ -446,17 +450,17 @@ _flags_genOptStr()
   _flags_opts_=''
 
   for _flags_name_ in ${__flags_longNames}; do
-    _flags_usName_=`_flags_underscoreName ${_flags_name_}`
-    _flags_type_=`_flags_getFlagInfo ${_flags_usName_} ${__FLAGS_INFO_TYPE}`
+    _flags_usName_="`_flags_underscoreName "${_flags_name_}"`"
+    _flags_type_="`_flags_getFlagInfo "${_flags_usName_}" "${__FLAGS_INFO_TYPE}"`"
     [ $? -eq ${FLAGS_TRUE} ] || _flags_fatal 'call to _flags_type_ failed'
     case ${_flags_optStrType_} in
       ${__FLAGS_OPTSTR_SHORT})
-        _flags_shortName_=`_flags_getFlagInfo \
-            ${_flags_usName_} ${__FLAGS_INFO_SHORT}`
+        _flags_shortName_="`_flags_getFlagInfo \
+            "${_flags_usName_}" "${__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_type_}" -ne "${__FLAGS_TYPE_BOOLEAN}" ] && \
               _flags_opts_="${_flags_opts_}:"
         fi
         ;;
@@ -464,7 +468,7 @@ _flags_genOptStr()
       ${__FLAGS_OPTSTR_LONG})
         _flags_opts_="${_flags_opts_:+${_flags_opts_},}${_flags_name_}"
         # getopt needs a trailing ':' to indicate a required argument
-        [ ${_flags_type_} -ne ${__FLAGS_TYPE_BOOLEAN} ] && \
+        [ "${_flags_type_}" -ne "${__FLAGS_TYPE_BOOLEAN}" ] && \
             _flags_opts_="${_flags_opts_}:"
         ;;
     esac
-- 
cgit v1.2.3


From 3355cdea10e4d413c30b6ef5a5528be3575c53de Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Mon, 16 Oct 2017 23:30:29 +0200
Subject: Fixed Issue #45, and cleaned up helpless help output.

---
 shflags | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 470bd1f..b6a117a 100644
--- a/shflags
+++ b/shflags
@@ -299,7 +299,7 @@ _flags_define()
   _flags_type_=$1
   _flags_name_=$2
   _flags_default_=$3
-  _flags_help_=$4
+  _flags_help_=${4:-§}  # Special value '§' indicates no help string provided.
   _flags_short_=${5:-${__FLAGS_NULL}}
 
   _flags_debug "type:${_flags_type_} name:${_flags_name_}" \
@@ -492,10 +492,16 @@ _flags_getFlagInfo()
   _flags_gFI_usName_=$1
   _flags_gFI_info_=$2
 
+  # Example: given argument usName (underscored flag name) of 'my_flag', and
+  # argument info of 'help', set the _flags_infoValue_ variable to the value of
+  # ${__flags_my_flag_help}, and see if it is non-empty.
   _flags_infoVar_="__flags_${_flags_gFI_usName_}_${_flags_gFI_info_}"
   _flags_strToEval_="_flags_infoValue_=\"\${${_flags_infoVar_}:-}\""
   eval "${_flags_strToEval_}"
-  if [ -n "${_flags_infoValue_+x}" ]; then
+  if [ -n "${_flags_infoValue_}" ]; then
+    # Special value '§' indicates no help string provided.
+    [ "${_flags_gFI_info_}" = ${__FLAGS_INFO_HELP} \
+        -a "${_flags_infoValue_}" = '§' ] && _flags_infoValue_=''
     flags_return=${FLAGS_TRUE}
   else
     # see if the _flags_gFI_usName_ variable is a string as strings can be
@@ -506,6 +512,9 @@ _flags_getFlagInfo()
     # 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 ;-)
+    #
+    # Example cont.: set the _flags_typeValue_ variable to the value of
+    # ${__flags_my_flag_type}, and see if it equals '4'.
     _flags_typeVar_="__flags_${_flags_gFI_usName_}_${__FLAGS_INFO_TYPE}"
     _flags_strToEval_="_flags_typeValue_=\"\${${_flags_typeVar_}:-}\""
     eval "${_flags_strToEval_}"
@@ -881,7 +890,7 @@ _flags_parseGetopt()
       if [ ${FLAGS_help} -eq ${FLAGS_TRUE} ]; then
         flags_help
         flags_error='help requested'
-        flags_return=${FLAGS_FALSE}
+        flags_return=${FLAGS_TRUE}
         break
       fi
     fi
@@ -1138,7 +1147,7 @@ flags_help()
       esac
       flags_defaultStr_="(default: ${flags_defaultStr_})"
 
-      flags_helpStr_="  ${flags_flagStr_}  ${flags_help_} ${flags_defaultStr_}"
+      flags_helpStr_="  ${flags_flagStr_}  ${flags_help_:+${flags_help_} }${flags_defaultStr_}"
       _flags_strlen "${flags_helpStr_}" >/dev/null
       flags_helpStrLen_=${flags_output}
       flags_columns_=`_flags_columns`
-- 
cgit v1.2.3


From f9a3d775b2beff3ff45a84b65e97a73c4df20107 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Mon, 16 Oct 2017 23:31:48 +0200
Subject: Comment and function declaration cleanups.

---
 shflags | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index b047f27..c2ddddb 100644
--- a/shflags
+++ b/shflags
@@ -489,9 +489,8 @@ _flags_genOptStr()
 #   string: value of dereferenced flag variable
 # Returns:
 #   integer: one of FLAGS_{TRUE|FALSE|ERROR}
-_flags_getFlagInfo()
-{
-  # note: adding gFI to variable names to prevent naming conflicts with calling
+_flags_getFlagInfo() {
+  # Note: adding gFI to variable names to prevent naming conflicts with calling
   # functions
   _flags_gFI_usName_=$1
   _flags_gFI_info_=$2
@@ -502,9 +501,9 @@ _flags_getFlagInfo()
   if [ -n "${_flags_infoValue_+x}" ]; then
     flags_return=${FLAGS_TRUE}
   else
-    # see if the _flags_gFI_usName_ variable is a string as strings can be
+    # See if the _flags_gFI_usName_ variable is a string as strings can be
     # empty...
-    # note: the DRY principle would say to have this function call itself for
+    # 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
@@ -996,13 +995,12 @@ DEFINE_string()  { _flags_define ${__FLAGS_TYPE_STRING} "$@"; }
 #   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
+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
+  # Parse options.
   if [ $# -gt 0 ]; then
     if [ ${__FLAGS_GETOPT_VERS} -ne ${__FLAGS_GETOPT_VERS_ENH} ]; then
       _flags_getoptStandard "$@"
@@ -1011,7 +1009,7 @@ FLAGS()
     fi
     flags_return=$?
   else
-    # nothing passed; won't bother running getopt
+    # Nothing passed; won't bother running getopt.
     __flags_opts='--'
     flags_return=${FLAGS_TRUE}
   fi
-- 
cgit v1.2.3


From 271a12cb0c7cb62f409c613365364aa6d3a850d8 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Wed, 18 Oct 2017 00:52:40 +0200
Subject: Ran shflags through ShellCheck.

---
 shflags | 115 +++++++++++++++++++++++++++++++---------------------------------
 1 file changed, 55 insertions(+), 60 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 91b84b3..ed83ec3 100644
--- a/shflags
+++ b/shflags
@@ -291,8 +291,7 @@ flags_setLoggingLevel() {
 #   _flags_short_: string: (optional) short flag name
 # Returns:
 #   integer: success of operation, or error
-_flags_define()
-{
+_flags_define() {
   if [ $# -lt 4 ]; then
     flags_error='DEFINE error: too few arguments'
     flags_return=${FLAGS_ERROR}
@@ -427,8 +426,7 @@ _flags_define()
 #   unnamed: string: log flag name
 # Output:
 #   string: underscored name
-_flags_underscoreName()
-{
+_flags_underscoreName() {
   echo "$1" |tr '-' '_'
 }
 
@@ -443,8 +441,7 @@ _flags_underscoreName()
 #   string: generated option string for getopt
 # Returns:
 #   boolean: success of operation (always returns True)
-_flags_genOptStr()
-{
+_flags_genOptStr() {
   _flags_optStrType_=$1
 
   _flags_opts_=''
@@ -521,6 +518,7 @@ _flags_getFlagInfo() {
     _flags_typeVar_="__flags_${_flags_gFI_usName_}_${__FLAGS_INFO_TYPE}"
     _flags_strToEval_="_flags_typeValue_=\"\${${_flags_typeVar_}:-}\""
     eval "${_flags_strToEval_}"
+    # shellcheck disable=SC2154
     if [ "${_flags_typeValue_}" = "${__FLAGS_TYPE_STRING}" ]; then
       flags_return=${FLAGS_TRUE}
     else
@@ -566,16 +564,18 @@ _flags_itemInList() {
 _flags_columns()
 {
   if [ -z "${__flags_columns}" ]; then
-    # determine the value and store it
+    # Determine the value and store it.
     if eval stty size >/dev/null 2>&1; then
       # stty size worked :-)
+      # shellcheck disable=SC2046
       set -- `stty size`
       __flags_columns=$2
     elif eval tput cols >/dev/null 2>&1; then
+      # shellcheck disable=SC2046
       set -- `tput cols`
       __flags_columns=$1
     else
-      __flags_columns=80  # default terminal width
+      __flags_columns=80  # Default terminal width.
     fi
   fi
   echo ${__flags_columns}
@@ -587,8 +587,7 @@ _flags_columns()
 #   _flags__bool: boolean: value to validate
 # Returns:
 #   bool: true if the value is a valid boolean
-_flags_validBool()
-{
+_flags_validBool() {
   _flags_bool_=$1
 
   flags_return=${FLAGS_TRUE}
@@ -613,13 +612,13 @@ _flags_validFloat() {
   [ -n "$1" ] || return ${flags_return}
   _flags_float_=$1
 
-  if _flags_validInt ${_flags_float_}; then
+  if _flags_validInt "${_flags_float_}"; then
     flags_return=${FLAGS_TRUE}
   elif _flags_useBuiltin; then
     _flags_float_whole_=${_flags_float_%.*}
     _flags_float_fraction_=${_flags_float_#*.}
-    if _flags_validInt ${_flags_float_whole_:-0} -a \
-      _flags_validInt ${_flags_float_fraction_}; then
+    if _flags_validInt "${_flags_float_whole_:-0}" -a \
+      _flags_validInt "${_flags_float_fraction_}"; then
       flags_return=${FLAGS_TRUE}
     fi
     unset _flags_float_whole_ _flags_float_fraction_
@@ -649,8 +648,7 @@ _flags_validFloat() {
 #   _flags_int_: integer: value to validate
 # Returns:
 #   bool: true if the value is a valid integer
-_flags_validInt()
-{
+_flags_validInt() {
   flags_return=${FLAGS_FALSE}
   [ -n "$1" ] || return ${flags_return}
   _flags_int_=$1
@@ -684,8 +682,7 @@ _flags_validInt()
 #   @: varies: command-line options to parse
 # Returns:
 #   integer: a FLAGS success condition
-_flags_getoptStandard()
-{
+_flags_getoptStandard() {
   flags_return=${FLAGS_TRUE}
   _flags_shortOpts_=`_flags_genOptStr ${__FLAGS_OPTSTR_SHORT}`
 
@@ -701,7 +698,7 @@ _flags_getoptStandard()
   done
 
   if [ ${flags_return} -eq ${FLAGS_TRUE} ]; then
-    __flags_opts=`getopt ${_flags_shortOpts_} $@ 2>&1`
+    __flags_opts=`getopt "${_flags_shortOpts_}" "$@" 2>&1`
     _flags_rtrn_=$?
     if [ ${_flags_rtrn_} -ne ${FLAGS_TRUE} ]; then
       _flags_warn "${__flags_opts}"
@@ -723,8 +720,7 @@ _flags_getoptStandard()
 #   @: varies: command-line options to parse
 # Returns:
 #   integer: a FLAGS success condition
-_flags_getoptEnhanced()
-{
+_flags_getoptEnhanced() {
   flags_return=${FLAGS_TRUE}
   _flags_shortOpts_=`_flags_genOptStr ${__FLAGS_OPTSTR_SHORT}`
   _flags_boolOpts_=`echo "${__flags_boolNames}" \
@@ -732,7 +728,7 @@ _flags_getoptEnhanced()
   _flags_longOpts_=`_flags_genOptStr ${__FLAGS_OPTSTR_LONG}`
 
   __flags_opts=`${FLAGS_GETOPT_CMD} \
-      -o ${_flags_shortOpts_} \
+      -o "${_flags_shortOpts_}" \
       -l "${_flags_longOpts_},${_flags_boolOpts_}" \
       -- "$@" 2>&1`
   _flags_rtrn_=$?
@@ -757,14 +753,15 @@ _flags_getoptEnhanced()
 #   @: varies: output from getopt parsing
 # Returns:
 #   integer: a FLAGS success condition
-_flags_parseGetopt()
-{
+_flags_parseGetopt() {
   _flags_argc_=$1
   shift
 
   flags_return=${FLAGS_TRUE}
 
   if [ ${__FLAGS_GETOPT_VERS} -ne ${__FLAGS_GETOPT_VERS_ENH} ]; then
+    # The @$ must be unquoted as it needs to be re-split.
+    #   shellcheck disable=SC2068
     set -- $@
   else
     # note the quotes around the `$@' -- they are essential!
@@ -777,6 +774,7 @@ _flags_parseGetopt()
   # arguments. Its usage was replaced by FLAGS_ARGV, and it is being kept only
   # for backwards compatibility reasons.
   FLAGS_ARGC=`_flags_math "$# - 1 - ${_flags_argc_}"`
+  export FLAGS_ARGC
 
   # handle options. note options with values must do an additional shift
   while true; do
@@ -796,11 +794,11 @@ _flags_parseGetopt()
           _flags_opt_=`${FLAGS_EXPR_CMD} "${_flags_opt_}" : '--\(.*\)'`
         fi
         _flags_len_=${__FLAGS_LEN_LONG}
-        if _flags_itemInList "${_flags_opt_}" ${__flags_longNames}; then
+        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
+          # Check for negated long boolean version.
+          if _flags_itemInList "${_flags_opt_}" "${__flags_boolNames}"; then
             if _flags_useBuiltin; then
               _flags_name_=${_flags_opt_#*no}
             else
@@ -812,34 +810,34 @@ _flags_parseGetopt()
         fi
         ;;
 
-      -*)  # short option
+      -*)  # Short option.
         if _flags_useBuiltin; then
           _flags_opt_=${_flags_opt_#*-}
         else
           _flags_opt_=`${FLAGS_EXPR_CMD} "${_flags_opt_}" : '-\(.*\)'`
         fi
         _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
+        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_}`
+                  e="${_flags_opt_}"`
           _flags_name_=`echo "${__flags_longNames}" \
               |awk 'BEGIN{RS=" "}rn==NR{print $0}' rn="${_flags_pos_}"`
         fi
         ;;
     esac
 
-    # die if the flag was unrecognized
+    # 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_usName_=`_flags_underscoreName ${_flags_name_}`
+    # Set new flag value.
+    _flags_usName_=`_flags_underscoreName "${_flags_name_}"`
     [ ${_flags_type_} -eq ${__FLAGS_TYPE_NONE} ] && \
         _flags_type_=`_flags_getFlagInfo \
             "${_flags_usName_}" ${__FLAGS_INFO_TYPE}`
@@ -855,7 +853,8 @@ _flags_parseGetopt()
           _flags_strToEval_="_flags_val_=\
 \${__flags_${_flags_usName_}_${__FLAGS_INFO_DEFAULT}}"
           eval "${_flags_strToEval_}"
-          if [ ${_flags_val_} -eq ${FLAGS_FALSE} ]; then
+          # shellcheck disable=SC2154
+          if [ "${_flags_val_}" -eq ${FLAGS_FALSE} ]; then
             eval "FLAGS_${_flags_usName_}=${FLAGS_TRUE}"
           else
             eval "FLAGS_${_flags_usName_}=${FLAGS_FALSE}"
@@ -888,9 +887,10 @@ _flags_parseGetopt()
         ;;
     esac
 
-    # handle special case help flag
+    # Handle special case help flag.
     if [ "${_flags_usName_}" = 'help' ]; then
-      if [ ${FLAGS_help} -eq ${FLAGS_TRUE} ]; then
+      # shellcheck disable=SC2154
+      if [ "${FLAGS_help}" -eq ${FLAGS_TRUE} ]; then
         flags_help
         flags_error='help requested'
         flags_return=${FLAGS_TRUE}
@@ -898,12 +898,12 @@ _flags_parseGetopt()
       fi
     fi
 
-    # shift the option and non-boolean arguments out.
+    # Shift the option and non-boolean arguments out.
     shift
-    [ ${_flags_type_} != ${__FLAGS_TYPE_BOOLEAN} ] && shift
+    [ "${_flags_type_}" != ${__FLAGS_TYPE_BOOLEAN} ] && shift
   done
 
-  # give user back non-flag arguments
+  # Give user back non-flag arguments.
   FLAGS_ARGV=''
   while [ $# -gt 0 ]; do
     FLAGS_ARGV="${FLAGS_ARGV:+${FLAGS_ARGV} }'$1'"
@@ -929,12 +929,13 @@ _flags_math() {
   elif _flags_useBuiltin; then
     # Variable assignment is needed as workaround for Solaris Bourne shell,
     # which cannot parse a bare $((expression)).
+    # shellcheck disable=SC2016
     _flags_expr_='$(($@))'
     eval echo ${_flags_expr_}
     flags_return=$?
     unset _flags_expr_
   else
-    eval expr $@
+    eval expr "$@"
     flags_return=$?
   fi
 
@@ -949,8 +950,7 @@ _flags_math() {
 #   integer: length of string
 # Returns:
 #   bool: success of strlen evaluation
-_flags_strlen()
-{
+_flags_strlen() {
   _flags_str_=${1:-}
 
   if [ -z "${_flags_str_}" ]; then
@@ -963,7 +963,7 @@ _flags_strlen()
   flags_return=$?
 
   unset _flags_str_
-  echo ${flags_output}
+  echo "${flags_output}"
   return ${flags_return}
 }
 
@@ -1042,8 +1042,7 @@ FLAGS() {
 #   debug info that can be included in a bug report
 # Returns:
 #   nothing
-flags_getoptInfo()
-{
+flags_getoptInfo() {
   # platform info
   _flags_debug "uname -a: `uname -a`"
   _flags_debug "PATH: ${PATH}"
@@ -1074,8 +1073,7 @@ flags_getoptInfo()
 #   none
 # Returns:
 #   bool: true if getopt is the enhanced version
-flags_getoptIsEnh()
-{
+flags_getoptIsEnh() {
   test ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_ENH}
 }
 
@@ -1085,8 +1083,7 @@ flags_getoptIsEnh()
 #   none
 # Returns:
 #   bool: true if getopt is the standard version
-flags_getoptIsStd()
-{
+flags_getoptIsStd() {
   test ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_STD}
 }
 
@@ -1099,8 +1096,7 @@ flags_getoptIsStd()
 #   none
 # Returns:
 #   integer: success of operation (always returns true)
-flags_help()
-{
+flags_help() {
   if [ -n "${FLAGS_HELP:-}" ]; then
     echo "${FLAGS_HELP}" >&2
   else
@@ -1111,7 +1107,7 @@ flags_help()
     for flags_name_ in ${__flags_longNames}; do
       flags_flagStr_=''
       flags_boolStr_=''
-      flags_usName_=`_flags_underscoreName ${flags_name_}`
+      flags_usName_=`_flags_underscoreName "${flags_name_}"`
 
       flags_default_=`_flags_getFlagInfo \
           "${flags_usName_}" ${__FLAGS_INFO_DEFAULT}`
@@ -1129,7 +1125,7 @@ flags_help()
         [ "${flags_short_}" != "${__FLAGS_NULL}" ] && \
             flags_flagStr_="${flags_flagStr_},"
         # add [no] to long boolean flag names, except the 'help' flag
-        [ ${flags_type_} -eq ${__FLAGS_TYPE_BOOLEAN} \
+        [ "${flags_type_}" -eq ${__FLAGS_TYPE_BOOLEAN} \
           -a "${flags_usName_}" != 'help' ] && \
             flags_boolStr_='[no]'
         flags_flagStr_="${flags_flagStr_}--${flags_boolStr_}${flags_name_}:"
@@ -1137,7 +1133,7 @@ flags_help()
 
       case ${flags_type_} in
         ${__FLAGS_TYPE_BOOLEAN})
-          if [ ${flags_default_} -eq ${FLAGS_TRUE} ]; then
+          if [ "${flags_default_}" -eq ${FLAGS_TRUE} ]; then
             flags_defaultStr_='true'
           else
             flags_defaultStr_='false'
@@ -1154,7 +1150,7 @@ flags_help()
       flags_helpStrLen_=${flags_output}
       flags_columns_=`_flags_columns`
 
-      if [ ${flags_helpStrLen_} -lt ${flags_columns_} ]; then
+      if [ "${flags_helpStrLen_}" -lt "${flags_columns_}" ]; then
         echo "${flags_helpStr_}" >&2
       else
         echo "  ${flags_flagStr_}  ${flags_help_}" >&2
@@ -1167,7 +1163,7 @@ flags_help()
         flags_helpStrLen_=${flags_output}
 
         if [ ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_STD} \
-            -o ${flags_helpStrLen_} -lt ${flags_columns_} ]; then
+            -o "${flags_helpStrLen_}" -lt "${flags_columns_}" ]; then
           # indented to match help string
           echo "${flags_helpStr_}" >&2
         else
@@ -1191,10 +1187,9 @@ flags_help()
 #   none
 # Returns:
 #   nothing
-flags_reset()
-{
+flags_reset() {
   for flags_name_ in ${__flags_longNames}; do
-    flags_usName_=`_flags_underscoreName ${flags_name_}`
+    flags_usName_=`_flags_underscoreName "${flags_name_}"`
     flags_strToEval_="unset FLAGS_${flags_usName_}"
     for flags_type_ in \
         ${__FLAGS_INFO_DEFAULT} \
@@ -1205,7 +1200,7 @@ flags_reset()
       flags_strToEval_=\
 "${flags_strToEval_} __flags_${flags_usName_}_${flags_type_}"
     done
-    eval ${flags_strToEval_}
+    eval "${flags_strToEval_}"
   done
 
   # Reset internal variables.
-- 
cgit v1.2.3


From 90379b1e41887c2948251c9320072d547ac27f90 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Wed, 18 Oct 2017 21:15:46 +0200
Subject: Bumped FLAGS_VERSION to 1.2.2.

---
 shflags | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index ed83ec3..2981e01 100644
--- a/shflags
+++ b/shflags
@@ -89,7 +89,7 @@
 
 # Return if FLAGS already loaded.
 [ -n "${FLAGS_VERSION:-}" ] && return 0
-FLAGS_VERSION='1.2.1'
+FLAGS_VERSION='1.2.2'
 
 # Return values that scripts can use.
 FLAGS_TRUE=0
-- 
cgit v1.2.3


From 78740ed6347816adcd7e863b0eb32099464a40a7 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Thu, 19 Oct 2017 12:57:09 +0200
Subject: Fixed bug in _flags_columns() for when `stty size` gives unexpected
 output.

---
 shflags | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 2981e01..a261802 100644
--- a/shflags
+++ b/shflags
@@ -561,24 +561,23 @@ _flags_itemInList() {
 #
 # Output:
 #   integer: width in columns of the current screen.
-_flags_columns()
-{
+_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 :-)
       # shellcheck disable=SC2046
       set -- `stty size`
-      __flags_columns=$2
-    elif eval tput cols >/dev/null 2>&1; then
+      __flags_columns="${2:-}"
+    fi
+  fi
+  if [ -z "${__flags_columns}" ]; then
+   if eval tput cols >/dev/null 2>&1; then
       # shellcheck disable=SC2046
       set -- `tput cols`
-      __flags_columns=$1
-    else
-      __flags_columns=80  # Default terminal width.
+      __flags_columns="${1:-}"
     fi
   fi
-  echo ${__flags_columns}
+  echo "${__flags_columns:-80}"
 }
 
 # Validate a boolean.
-- 
cgit v1.2.3


From 16e8d0d3a58dfe8ccc0423b2cfbdf8119e7a86d7 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Sat, 21 Oct 2017 19:45:29 +0200
Subject: Fixed #47. A call for help should return a non-zero exit code.

---
 shflags | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index a261802..1ed2d00 100644
--- a/shflags
+++ b/shflags
@@ -892,7 +892,7 @@ _flags_parseGetopt() {
       if [ "${FLAGS_help}" -eq ${FLAGS_TRUE} ]; then
         flags_help
         flags_error='help requested'
-        flags_return=${FLAGS_TRUE}
+        flags_return=${FLAGS_FALSE}
         break
       fi
     fi
-- 
cgit v1.2.3


From 61c6d0e4ecc70cee21a920ad15cd5f6de2e7a694 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Sat, 21 Oct 2017 21:08:52 +0200
Subject: Fixed #46. Improved getopt version determination.

---
 shflags | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 1ed2d00..44a9dd8 100644
--- a/shflags
+++ b/shflags
@@ -118,7 +118,7 @@ else
   unset _flags_output_
 fi
 
-# Commands a user can override if needed.
+# Commands a user can override if desired.
 FLAGS_EXPR_CMD=${FLAGS_EXPR_CMD:-${__FLAGS_EXPR_CMD}}
 FLAGS_GETOPT_CMD=${FLAGS_GETOPT_CMD:-getopt}
 
@@ -151,24 +151,23 @@ fi
 __FLAGS_RESERVED_LIST=' ARGC ARGV ERROR FALSE GETOPT_CMD HELP PARENT TRUE '
 __FLAGS_RESERVED_LIST="${__FLAGS_RESERVED_LIST} VERSION "
 
-# getopt version.
+# Determined getopt version (standard or enhanced).
 __FLAGS_GETOPT_VERS_STD=0
 __FLAGS_GETOPT_VERS_ENH=1
 
-${FLAGS_GETOPT_CMD} >/dev/null 2>&1
-case $? in
-  0) __FLAGS_GETOPT_VERS=${__FLAGS_GETOPT_VERS_STD} ;;  # bsd getopt
-  1) __FLAGS_GETOPT_VERS=${__FLAGS_GETOPT_VERS_ENH} ;;  # BusyBox getopt.
-  2)
-    # TODO(kward): look into '-T' option to test the internal getopt() version
-    if [ "`${FLAGS_GETOPT_CMD} --version`" = '-- ' ]; then
-      __FLAGS_GETOPT_VERS=${__FLAGS_GETOPT_VERS_STD}
-    else
-      __FLAGS_GETOPT_VERS=${__FLAGS_GETOPT_VERS_ENH}
-    fi
-    ;;
-  *) _flags_fatal 'unable to determine getopt version' ;;
-esac
+# shellcheck disable=SC2120
+_flags_getopt_vers() {
+  _flags_getopt_cmd_=${1:-${FLAGS_GETOPT_CMD}}
+  case "`${_flags_getopt_cmd_} -lfoo '' --foo 2>&1`" in
+    ' -- --foo') echo ${__FLAGS_GETOPT_VERS_STD} ;;
+    ' --foo --') echo ${__FLAGS_GETOPT_VERS_ENH} ;;
+    # Unrecognized output. Assuming standard getopt version.
+    *) echo ${__FLAGS_GETOPT_VERS_STD} ;;
+  esac
+  unset _flags_getopt_cmd_
+}
+# shellcheck disable=SC2119
+__FLAGS_GETOPT_VERS=`_flags_getopt_vers`
 
 # getopt optstring lengths
 __FLAGS_OPTSTR_SHORT=0
-- 
cgit v1.2.3


From 638ed7820abd10118e88db6bc9771487de66e5f5 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Sat, 21 Oct 2017 21:29:59 +0200
Subject: Ran through ShellCheck. Again.

---
 shflags | 55 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 28 insertions(+), 27 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 44a9dd8..1a7cf93 100644
--- a/shflags
+++ b/shflags
@@ -82,6 +82,7 @@
 # Notes:
 # - lists of strings are space separated, and a null value is the '~' char.
 #
+### ShellCheck (http://www.shellcheck.net/)
 # $() are not fully portable (POSIX != portable).
 #   shellcheck disable=SC2006
 # [ p -a q ] are well defined enough (vs [ p ] && [ q ]).
@@ -89,7 +90,7 @@
 
 # Return if FLAGS already loaded.
 [ -n "${FLAGS_VERSION:-}" ] && return 0
-FLAGS_VERSION='1.2.2'
+FLAGS_VERSION='1.2.2pre'
 
 # Return values that scripts can use.
 FLAGS_TRUE=0
@@ -311,23 +312,23 @@ _flags_define() {
   _flags_return_=${FLAGS_TRUE}
   _flags_usName_="`_flags_underscoreName "${_flags_name_}"`"
 
-  # check whether the flag name is reserved
+  # Check whether the flag name is reserved.
   _flags_itemInList "${_flags_usName_}" "${__FLAGS_RESERVED_LIST}"
   if [ $? -eq ${FLAGS_TRUE} ]; 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
+  # 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_GETOPT_VERS}" -ne "${__FLAGS_GETOPT_VERS_ENH}" \
       -a "${_flags_short_}" = "${__FLAGS_NULL}" ]
   then
     flags_error="short flag required for (${_flags_name_}) on this platform"
     _flags_return_=${FLAGS_ERROR}
   fi
 
-  # check for existing long name definition
+  # Check for existing long name definition.
   if [ ${_flags_return_} -eq ${FLAGS_TRUE} ]; then
     if _flags_itemInList "${_flags_usName_}" "${__flags_definedNames}"; then
       flags_error="definition for ([no]${_flags_name_}) already exists"
@@ -336,7 +337,7 @@ _flags_define() {
     fi
   fi
 
-  # check for existing short name definition
+  # Check for existing short name definition.
   if [ ${_flags_return_} -eq ${FLAGS_TRUE} \
       -a "${_flags_short_}" != "${__FLAGS_NULL}" ]
   then
@@ -347,8 +348,8 @@ _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
+  # 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
@@ -382,7 +383,7 @@ _flags_define() {
         fi
         ;;
 
-      ${__FLAGS_TYPE_STRING}) ;;  # everything in shell is a valid string
+      ${__FLAGS_TYPE_STRING}) ;;  # Everything in shell is a valid string.
 
       *)
         flags_error="unrecognized flag type '${_flags_type_}'"
@@ -406,7 +407,7 @@ _flags_define() {
     [ "${_flags_type_}" -eq "${__FLAGS_TYPE_BOOLEAN}" ] && \
         __flags_boolNames="${__flags_boolNames}no${_flags_name_} "
 
-    # append flag names to defined names for later validation checks
+    # Append flag names to defined names for later validation checks.
     __flags_definedNames="${__flags_definedNames}${_flags_usName_} "
     [ "${_flags_type_}" -eq "${__FLAGS_TYPE_BOOLEAN}" ] && \
         __flags_definedNames="${__flags_definedNames}no${_flags_usName_} "
@@ -455,7 +456,7 @@ _flags_genOptStr() {
             "${_flags_usName_}" "${__FLAGS_INFO_SHORT}"`"
         if [ "${_flags_shortName_}" != "${__FLAGS_NULL}" ]; then
           _flags_opts_="${_flags_opts_}${_flags_shortName_}"
-          # getopt needs a trailing ':' to indicate a required argument
+          # getopt needs a trailing ':' to indicate a required argument.
           [ "${_flags_type_}" -ne "${__FLAGS_TYPE_BOOLEAN}" ] && \
               _flags_opts_="${_flags_opts_}:"
         fi
@@ -623,11 +624,11 @@ _flags_validFloat() {
   else
     flags_return=${FLAGS_TRUE}
     case ${_flags_float_} in
-      -*)  # negative floats
+      -*)  # Negative floats.
         _flags_test_=`${FLAGS_EXPR_CMD} "${_flags_float_}" :\
             '\(-[0-9]*\.[0-9]*\)'`
         ;;
-      *)  # positive floats
+      *)  # Positive floats.
         _flags_test_=`${FLAGS_EXPR_CMD} "${_flags_float_}" :\
             '\([0-9]*\.[0-9]*\)'`
         ;;
@@ -652,8 +653,8 @@ _flags_validInt() {
   _flags_int_=$1
 
   case ${_flags_int_} in
-    -*.*) ;;  # ignore negative floats (we'll invalidate them later)
-    -*)  # strip possible leading negative sign
+    -*.*) ;;  # Ignore negative floats (we'll invalidate them later).
+    -*)  # Strip possible leading negative sign.
       if _flags_useBuiltin; then
         _flags_int_=${_flags_int_#-}
       else
@@ -684,9 +685,9 @@ _flags_getoptStandard() {
   flags_return=${FLAGS_TRUE}
   _flags_shortOpts_=`_flags_genOptStr ${__FLAGS_OPTSTR_SHORT}`
 
-  # check for spaces in passed options
+  # 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
+    # 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'
@@ -757,12 +758,12 @@ _flags_parseGetopt() {
 
   flags_return=${FLAGS_TRUE}
 
-  if [ ${__FLAGS_GETOPT_VERS} -ne ${__FLAGS_GETOPT_VERS_ENH} ]; then
+  if [ "${__FLAGS_GETOPT_VERS}" -ne "${__FLAGS_GETOPT_VERS_ENH}" ]; then
     # The @$ must be unquoted as it needs to be re-split.
     #   shellcheck disable=SC2068
     set -- $@
   else
-    # note the quotes around the `$@' -- they are essential!
+    # Note the quotes around the `$@' -- they are essential!
     eval set -- "$@"
   fi
 
@@ -781,11 +782,11 @@ _flags_parseGetopt() {
     _flags_type_=${__FLAGS_TYPE_NONE}
     _flags_name_=''
 
-    # determine long flag name
+    # Determine long flag name.
     case "${_flags_opt_}" in
-      --) shift; break ;;  # discontinue option parsing
+      --) shift; break ;;  # Discontinue option parsing.
 
-      --*)  # long option
+      --*)  # Long option.
         if _flags_useBuiltin; then
           _flags_opt_=${_flags_opt_#*--}
         else
@@ -1009,7 +1010,7 @@ FLAGS() {
 
   # Parse options.
   if [ $# -gt 0 ]; then
-    if [ ${__FLAGS_GETOPT_VERS} -ne ${__FLAGS_GETOPT_VERS_ENH} ]; then
+    if [ "${__FLAGS_GETOPT_VERS}" -ne "${__FLAGS_GETOPT_VERS_ENH}" ]; then
       _flags_getoptStandard "$@"
     else
       _flags_getoptEnhanced "$@"
@@ -1072,7 +1073,7 @@ flags_getoptInfo() {
 # Returns:
 #   bool: true if getopt is the enhanced version
 flags_getoptIsEnh() {
-  test ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_ENH}
+  test "${__FLAGS_GETOPT_VERS}" -eq "${__FLAGS_GETOPT_VERS_ENH}"
 }
 
 # Returns whether the detected getopt version is the standard version.
@@ -1082,7 +1083,7 @@ flags_getoptIsEnh() {
 # Returns:
 #   bool: true if getopt is the standard version
 flags_getoptIsStd() {
-  test ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_STD}
+  test "${__FLAGS_GETOPT_VERS}" -eq "${__FLAGS_GETOPT_VERS_STD}"
 }
 
 # This is effectively a 'usage()' function. It prints usage information and
@@ -1119,7 +1120,7 @@ flags_help() {
       [ "${flags_short_}" != "${__FLAGS_NULL}" ] && \
           flags_flagStr_="-${flags_short_}"
 
-      if [ ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_ENH} ]; then
+      if [ "${__FLAGS_GETOPT_VERS}" -eq "${__FLAGS_GETOPT_VERS_ENH}" ]; then
         [ "${flags_short_}" != "${__FLAGS_NULL}" ] && \
             flags_flagStr_="${flags_flagStr_},"
         # add [no] to long boolean flag names, except the 'help' flag
@@ -1160,7 +1161,7 @@ flags_help() {
         _flags_strlen "${flags_helpStr_}" >/dev/null
         flags_helpStrLen_=${flags_output}
 
-        if [ ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_STD} \
+        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
-- 
cgit v1.2.3


From 47237bc03c1b86c6fb157e59efe1756488727a7a Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Sat, 21 Oct 2017 21:37:34 +0200
Subject: Capitalizing sentences and adding periods.

---
 shflags | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 1a7cf93..fbf064e 100644
--- a/shflags
+++ b/shflags
@@ -775,7 +775,7 @@ _flags_parseGetopt() {
   FLAGS_ARGC=`_flags_math "$# - 1 - ${_flags_argc_}"`
   export FLAGS_ARGC
 
-  # handle options. note options with values must do an additional shift
+  # Handle options. note options with values must do an additional shift.
   while true; do
     _flags_opt_=$1
     _flags_arg_=${2:-}
@@ -1042,11 +1042,11 @@ FLAGS() {
 # Returns:
 #   nothing
 flags_getoptInfo() {
-  # platform info
+  # Platform info.
   _flags_debug "uname -a: `uname -a`"
   _flags_debug "PATH: ${PATH}"
 
-  # shell info
+  # Shell info.
   if [ -n "${BASH_VERSION:-}" ]; then
     _flags_debug 'shell: bash'
     _flags_debug "BASH_VERSION: ${BASH_VERSION}"
@@ -1055,7 +1055,7 @@ flags_getoptInfo() {
     _flags_debug "ZSH_VERSION: ${ZSH_VERSION}"
   fi
 
-  # getopt info
+  # getopt info.
   ${FLAGS_GETOPT_CMD} >/dev/null
   _flags_getoptReturn=$?
   _flags_debug "getopt return: ${_flags_getoptReturn}"
@@ -1123,7 +1123,7 @@ flags_help() {
       if [ "${__FLAGS_GETOPT_VERS}" -eq "${__FLAGS_GETOPT_VERS_ENH}" ]; then
         [ "${flags_short_}" != "${__FLAGS_NULL}" ] && \
             flags_flagStr_="${flags_flagStr_},"
-        # add [no] to long boolean flag names, except the 'help' flag
+        # Add [no] to long boolean flag names, except the 'help' flag.
         [ "${flags_type_}" -eq ${__FLAGS_TYPE_BOOLEAN} \
           -a "${flags_usName_}" != 'help' ] && \
             flags_boolStr_='[no]'
@@ -1153,7 +1153,7 @@ 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
+        # 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", ""}'`"
@@ -1163,11 +1163,11 @@ flags_help() {
 
         if [ "${__FLAGS_GETOPT_VERS}" -eq "${__FLAGS_GETOPT_VERS_STD}" \
             -o "${flags_helpStrLen_}" -lt "${flags_columns_}" ]; then
-          # indented to match help string
+          # 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
+          # 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
-- 
cgit v1.2.3


From b1b27150f0310bf82913baf8509e7b71bfd082f9 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Sun, 22 Oct 2017 14:15:52 +0200
Subject: Bumped version to 1.2.3pre there was already a 1.2.2 release.

---
 shflags | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index fbf064e..70cdea4 100644
--- a/shflags
+++ b/shflags
@@ -90,7 +90,7 @@
 
 # Return if FLAGS already loaded.
 [ -n "${FLAGS_VERSION:-}" ] && return 0
-FLAGS_VERSION='1.2.2pre'
+FLAGS_VERSION='1.2.3pre'
 
 # Return values that scripts can use.
 FLAGS_TRUE=0
-- 
cgit v1.2.3


From e563d4c1731683908c05782f07bfac48856f3139 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Mon, 15 Jan 2018 11:28:57 +0100
Subject: Reordered comments in header.

---
 shflags | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 70cdea4..672ac39 100644
--- a/shflags
+++ b/shflags
@@ -1,13 +1,13 @@
 # vim:et:ft=sh:sts=2:sw=2
 #
-# Copyright 2008-2017 Kate Ward. All Rights Reserved.
+# Copyright 2008-2018 Kate Ward. All Rights Reserved.
 # Released under the Apache License 2.0 license.
 # http://www.apache.org/licenses/LICENSE-2.0
 #
-# shFlags -- Advanced command-line flag library for Unix shell scripts.
-# https://github.com/kward/shflags
+# shFlags is an advanced command-line flag library for Unix shell scripts.
 #
 # Author: kate.ward@forestent.com (Kate Ward)
+# https://github.com/kward/shflags
 #
 # This module implements something like the gflags library available
 # from https://github.com/gflags/gflags.
-- 
cgit v1.2.3


From a8e81fdb77b054dc28987af82e53ab9a0c107d20 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Mon, 15 Jan 2018 11:31:02 +0100
Subject: Added unit test for underscoreName(), and fixed potential POSIX
 compliance issue.

---
 shflags | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 672ac39..c8dd5fe 100644
--- a/shflags
+++ b/shflags
@@ -427,7 +427,7 @@ _flags_define() {
 # Output:
 #   string: underscored name
 _flags_underscoreName() {
-  echo "$1" |tr '-' '_'
+  echo "$1" |tr z- z_
 }
 
 # Return valid getopt options using currently defined list of long options.
-- 
cgit v1.2.3


From eef376e159c9c1f7c3ebd2b6a28ecef9f688efc9 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Tue, 16 Jan 2018 23:22:37 +0100
Subject: Validate that globbing works in _flags_itemInList().

---
 shflags | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index c8dd5fe..a6ce471 100644
--- a/shflags
+++ b/shflags
@@ -545,7 +545,7 @@ _flags_getFlagInfo() {
 # Returns:
 #   boolean: true if item is in the list
 _flags_itemInList() {
-  _flags_str_=$1
+  _flags_str_="$1"
   shift
 
   case " ${*:-} " in
-- 
cgit v1.2.3


From e64fc760c5d4072be19a0d0c53000d29ddacad8b Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Tue, 16 Jan 2018 23:49:41 +0100
Subject: Changed my mind. Not quoting a $1 variable.

---
 shflags | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index a6ce471..c8dd5fe 100644
--- a/shflags
+++ b/shflags
@@ -545,7 +545,7 @@ _flags_getFlagInfo() {
 # Returns:
 #   boolean: true if item is in the list
 _flags_itemInList() {
-  _flags_str_="$1"
+  _flags_str_=$1
   shift
 
   case " ${*:-} " in
-- 
cgit v1.2.3


From 4a9ecdede54c53edceed75423f5fc5cbbc62bf83 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Wed, 17 Jan 2018 00:08:36 +0100
Subject: Replaced _flags_validInt() with much simpler code.

---
 shflags | 24 ++----------------------
 1 file changed, 2 insertions(+), 22 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index c8dd5fe..d8b1dff 100644
--- a/shflags
+++ b/shflags
@@ -616,6 +616,7 @@ _flags_validFloat() {
   elif _flags_useBuiltin; then
     _flags_float_whole_=${_flags_float_%.*}
     _flags_float_fraction_=${_flags_float_#*.}
+    [ "${_flags_float_whole_}" = '-' ] && _flags_float_whole_='-0'
     if _flags_validInt "${_flags_float_whole_:-0}" -a \
       _flags_validInt "${_flags_float_fraction_}"; then
       flags_return=${FLAGS_TRUE}
@@ -648,28 +649,7 @@ _flags_validFloat() {
 # Returns:
 #   bool: true if the value is a valid integer
 _flags_validInt() {
-  flags_return=${FLAGS_FALSE}
-  [ -n "$1" ] || return ${flags_return}
-  _flags_int_=$1
-
-  case ${_flags_int_} in
-    -*.*) ;;  # Ignore negative floats (we'll invalidate them later).
-    -*)  # Strip possible leading negative sign.
-      if _flags_useBuiltin; then
-        _flags_int_=${_flags_int_#-}
-      else
-        _flags_int_=`${FLAGS_EXPR_CMD} "${_flags_int_}" : '-\([0-9][0-9]*\)'`
-      fi
-      ;;
-  esac
-
-  case ${_flags_int_} in
-    *[!0-9]*) flags_return=${FLAGS_FALSE} ;;
-    *) flags_return=${FLAGS_TRUE} ;;
-  esac
-
-  unset _flags_int_
-  return ${flags_return}
+  expr \( "$1" + '0' \) '=' "$1" >/dev/null 2>&1
 }
 
 # Parse command-line options using the standard getopt.
-- 
cgit v1.2.3


From 3908d0f7c3bc364251860670605d62a37e3f7fcd Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Thu, 18 Jan 2018 01:05:45 +0100
Subject: Fixed ShellCheck issues.

---
 shflags | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'shflags')

diff --git a/shflags b/shflags
index d8b1dff..7232940 100644
--- a/shflags
+++ b/shflags
@@ -83,6 +83,8 @@
 # - lists of strings are space separated, and a null value is the '~' char.
 #
 ### ShellCheck (http://www.shellcheck.net/)
+# expr may be antiquated, but it is the only solution in some cases.
+#   shellcheck disable=SC2003
 # $() are not fully portable (POSIX != portable).
 #   shellcheck disable=SC2006
 # [ p -a q ] are well defined enough (vs [ p ] && [ q ]).
-- 
cgit v1.2.3


From 9123f58a2e024398adc92e4d4eb32a06a3afc674 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Thu, 25 Jan 2018 12:54:08 +0100
Subject: Moved logging code earlier so it can be used during initialization.

---
 shflags | 100 +++++++++++++++++++++++++++++++++-------------------------------
 1 file changed, 51 insertions(+), 49 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 7232940..ed55676 100644
--- a/shflags
+++ b/shflags
@@ -125,7 +125,57 @@ fi
 FLAGS_EXPR_CMD=${FLAGS_EXPR_CMD:-${__FLAGS_EXPR_CMD}}
 FLAGS_GETOPT_CMD=${FLAGS_GETOPT_CMD:-getopt}
 
-# Specific shell checks.
+#
+# Logging functions.
+#
+
+__flags_level=0 # Default logging level.
+
+_flags_debug() {
+  [ ${__flags_level} -le ${FLAGS_LEVEL_DEBUG} ] || return
+  echo "flags:DEBUG $*" >&2
+}
+_flags_info() {
+  [ ${__flags_level} -le ${FLAGS_LEVEL_INFO} ] || return
+  echo "flags:INFO $*" >&2
+}
+_flags_warn() {
+  [ ${__flags_level} -le ${FLAGS_LEVEL_WARN} ] || return
+  echo "flags:WARN $*" >&2
+}
+_flags_error() {
+  [ ${__flags_level} -le ${FLAGS_LEVEL_ERROR} ] || return
+  echo "flags:ERROR $*" >&2
+}
+_flags_fatal() {
+  [ ${__flags_level} -le ${FLAGS_LEVEL_FATAL} ] || return
+  echo "flags:FATAL $*" >&2
+  exit ${FLAGS_ERROR}
+}
+
+# Get the logging level.
+flags_loggingLevel() { echo ${__flags_level}; }
+
+# Set the logging level.
+#
+# Args:
+#   _flags_level_: integer: new logging level
+# Returns:
+#   nothing
+flags_setLoggingLevel() {
+  [ $# -ne 1 ] && _flags_fatal "flags_setLevel(): logging level missing"
+  _flags_level_=$1
+  [ "${_flags_level_}" -ge "${FLAGS_LEVEL_DEBUG}" \
+    -a "${_flags_level_}" -le "${FLAGS_LEVEL_FATAL}" ] \
+      || _flags_fatal "Invalid logging level '${_flags_level_}' specified."
+  __flags_level=$1
+  unset _flags_level_
+}
+
+#
+# Shell checks.
+#
+
 if [ -n "${ZSH_VERSION:-}" ]; then
   setopt |grep "^shwordsplit$" >/dev/null
   if [ $? -ne ${FLAGS_TRUE} ]; then
@@ -145,7 +195,6 @@ else
   __FLAGS_USE_BUILTIN=${FLAGS_FALSE}
 fi
 
-
 #
 # Constants.
 #
@@ -226,55 +275,8 @@ __flags_shortNames=' '    # Short flag names.
 __flags_definedNames=' '  # Defined flag names (used for validation).
 
 __flags_columns=''  # Screen width in columns.
-__flags_level=0     # Default logging level.
 __flags_opts=''     # Temporary storage for parsed getopt flags.
 
-#------------------------------------------------------------------------------
-# Private functions.
-#
-
-# Logging functions.
-_flags_debug() {
-  [ ${__flags_level} -le ${FLAGS_LEVEL_DEBUG} ] || return
-  echo "flags:DEBUG $*" >&2
-}
-_flags_info() {
-  [ ${__flags_level} -le ${FLAGS_LEVEL_INFO} ] || return
-  echo "flags:INFO $*" >&2
-}
-_flags_warn() {
-  [ ${__flags_level} -le ${FLAGS_LEVEL_WARN} ] || return
-  echo "flags:WARN $*" >&2
-}
-_flags_error() {
-  [ ${__flags_level} -le ${FLAGS_LEVEL_ERROR} ] || return
-  echo "flags:ERROR $*" >&2
-}
-_flags_fatal() {
-  [ ${__flags_level} -le ${FLAGS_LEVEL_FATAL} ] || return
-  echo "flags:FATAL $*" >&2
-  exit ${FLAGS_ERROR}
-}
-
-# Get the logging level.
-flags_loggingLevel() { echo ${__flags_level}; }
-
-# Set the logging level.
-#
-# Args:
-#   _flags_level_: integer: new logging level
-# Returns:
-#   nothing
-flags_setLoggingLevel() {
-  [ $# -ne 1 ] && _flags_fatal "flags_setLevel(): logging level missing"
-  _flags_level_=$1
-  [ "${_flags_level_}" -ge "${FLAGS_LEVEL_DEBUG}" \
-    -a "${_flags_level_}" -le "${FLAGS_LEVEL_FATAL}" ] \
-      || _flags_fatal "Invalid logging level '${_flags_level_}' specified."
-  __flags_level=$1
-  unset _flags_level_
-}
-
 # Define a flag.
 #
 # Calling this function will define the following info variables for the
-- 
cgit v1.2.3


From b028d78a70b04986f65d0166ec0cf33e50eec598 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Thu, 25 Jan 2018 18:18:59 +0100
Subject: Prep for v1.2.3 release.

---
 shflags | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index ed55676..38495e1 100644
--- a/shflags
+++ b/shflags
@@ -92,7 +92,7 @@
 
 # Return if FLAGS already loaded.
 [ -n "${FLAGS_VERSION:-}" ] && return 0
-FLAGS_VERSION='1.2.3pre'
+FLAGS_VERSION='1.2.3'
 
 # Return values that scripts can use.
 FLAGS_TRUE=0
-- 
cgit v1.2.3


From 8c168e58cadd5bf92ed5bfc02c159b9251cf3eea Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Tue, 11 Feb 2020 04:18:45 +0100
Subject: Fixed recent shellcheck errors.

---
 shflags | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 38495e1..62a8e22 100644
--- a/shflags
+++ b/shflags
@@ -259,7 +259,10 @@ for __flags_const in ${__flags_constants}; do
   fi
   case ${ZSH_VERSION} in
     [123].*) readonly "${__flags_const}" ;;
-    *) readonly -g "${__flags_const}" ;;  # Declare readonly constants globally.
+    *)
+      # Declare readonly constants globally.
+      # shellcheck disable=SC2039
+      readonly -g "${__flags_const}" ;;
   esac
 done
 unset __flags_const __flags_constants
-- 
cgit v1.2.3


From cbc669de0a03d50dced5c9259b1e0db2deb60ffa Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Sun, 29 Mar 2020 15:44:19 +0200
Subject: Starting a new 1.2.4 release series.

---
 shflags | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 62a8e22..e907ba7 100644
--- a/shflags
+++ b/shflags
@@ -1,6 +1,6 @@
 # vim:et:ft=sh:sts=2:sw=2
 #
-# Copyright 2008-2018 Kate Ward. All Rights Reserved.
+# Copyright 2008-2020 Kate Ward. All Rights Reserved.
 # Released under the Apache License 2.0 license.
 # http://www.apache.org/licenses/LICENSE-2.0
 #
@@ -92,7 +92,7 @@
 
 # Return if FLAGS already loaded.
 [ -n "${FLAGS_VERSION:-}" ] && return 0
-FLAGS_VERSION='1.2.3'
+FLAGS_VERSION='1.2.4pre'
 
 # Return values that scripts can use.
 FLAGS_TRUE=0
-- 
cgit v1.2.3


From 9cfea86e50ba4740899e4619e466b860009b49a0 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Sun, 29 Mar 2020 23:59:46 +0200
Subject: Reworked to fix test failures on both macOS and Linux.

---
 shflags | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index e907ba7..d98f775 100644
--- a/shflags
+++ b/shflags
@@ -1060,7 +1060,7 @@ flags_getoptInfo() {
 # Returns:
 #   bool: true if getopt is the enhanced version
 flags_getoptIsEnh() {
-  test "${__FLAGS_GETOPT_VERS}" -eq "${__FLAGS_GETOPT_VERS_ENH}"
+  test ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_ENH}
 }
 
 # Returns whether the detected getopt version is the standard version.
@@ -1070,7 +1070,7 @@ flags_getoptIsEnh() {
 # Returns:
 #   bool: true if getopt is the standard version
 flags_getoptIsStd() {
-  test "${__FLAGS_GETOPT_VERS}" -eq "${__FLAGS_GETOPT_VERS_STD}"
+  test ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_STD}
 }
 
 # This is effectively a 'usage()' function. It prints usage information and
-- 
cgit v1.2.3


From 16a3af2e404d63e75881be9055f1a1afc698d363 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Mon, 30 Mar 2020 00:09:16 +0200
Subject: Fixed ShellCheck warnings.

---
 shflags | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index d98f775..e907ba7 100644
--- a/shflags
+++ b/shflags
@@ -1060,7 +1060,7 @@ flags_getoptInfo() {
 # Returns:
 #   bool: true if getopt is the enhanced version
 flags_getoptIsEnh() {
-  test ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_ENH}
+  test "${__FLAGS_GETOPT_VERS}" -eq "${__FLAGS_GETOPT_VERS_ENH}"
 }
 
 # Returns whether the detected getopt version is the standard version.
@@ -1070,7 +1070,7 @@ flags_getoptIsEnh() {
 # Returns:
 #   bool: true if getopt is the standard version
 flags_getoptIsStd() {
-  test ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_STD}
+  test "${__FLAGS_GETOPT_VERS}" -eq "${__FLAGS_GETOPT_VERS_STD}"
 }
 
 # This is effectively a 'usage()' function. It prints usage information and
-- 
cgit v1.2.3


From d368f831e7db7e41aa95b5a4ea9817cfa952983b Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Thu, 9 Apr 2020 10:53:53 +0200
Subject: Fixed expr command determination to work with 'set -e'.

---
 shflags | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index e907ba7..46ca3d7 100644
--- a/shflags
+++ b/shflags
@@ -108,18 +108,25 @@ FLAGS_LEVEL_FATAL=4
 __FLAGS_LEVEL_DEFAULT=${FLAGS_LEVEL_WARN}
 
 # Determine some reasonable command defaults.
-__FLAGS_EXPR_CMD='expr --'
-__FLAGS_UNAME_S=`uname -s`
-if [ "${__FLAGS_UNAME_S}" = 'BSD' ]; then
-  __FLAGS_EXPR_CMD='gexpr --'
-else
-  _flags_output_=`${__FLAGS_EXPR_CMD} 2>&1`
-  if [ $? -eq ${FLAGS_TRUE} -a "${_flags_output_}" = '--' ]; then
-    # We are likely running inside BusyBox.
-    __FLAGS_EXPR_CMD='expr'
+_flags_expr_cmd() {
+  if [ "$(uname -s)" = 'BSD' ]; then
+    echo 'gexpr --'
+    return 0
   fi
-  unset _flags_output_
-fi
+
+  _flags_expr_cmd_='expr --'
+  # shellcheck disable=SC2003
+  if _flags_output_=$(expr -- 2>&1); then
+    if [ "${_flags_output_}" = '--' ]; then
+      # We are likely running inside BusyBox.
+      _flags_expr_cmd_='expr'
+    fi
+  fi
+
+  echo "${_flags_expr_cmd_}"
+  unset _flags_expr_cmd_ _flags_output_
+}
+__FLAGS_EXPR_CMD=`_flags_expr_cmd`
 
 # Commands a user can override if desired.
 FLAGS_EXPR_CMD=${FLAGS_EXPR_CMD:-${__FLAGS_EXPR_CMD}}
@@ -1201,7 +1208,7 @@ flags_reset() {
   unset flags_name_ flags_type_ flags_strToEval_ flags_usName_
 }
 
-#
+#-----------------------------------------------------------------------------
 # Initialization
 #
 
-- 
cgit v1.2.3


From 7cafbef7743c487216a619c1fcb2a34b60a7e7e2 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Thu, 9 Apr 2020 17:52:50 +0200
Subject: Refactored logging code and fixed some 'set -e' issues.

---
 shflags | 73 +++++++++++++++++++++++++++++++++++------------------------------
 1 file changed, 39 insertions(+), 34 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 46ca3d7..da09932 100644
--- a/shflags
+++ b/shflags
@@ -91,7 +91,7 @@
 #   shellcheck disable=SC2166
 
 # Return if FLAGS already loaded.
-[ -n "${FLAGS_VERSION:-}" ] && return 0
+if [ -n "${FLAGS_VERSION:-}" ]; then return 0; fi
 FLAGS_VERSION='1.2.4pre'
 
 # Return values that scripts can use.
@@ -99,34 +99,38 @@ FLAGS_TRUE=0
 FLAGS_FALSE=1
 FLAGS_ERROR=2
 
-# Logging levels.
-FLAGS_LEVEL_DEBUG=0
-FLAGS_LEVEL_INFO=1
-FLAGS_LEVEL_WARN=2
-FLAGS_LEVEL_ERROR=3
-FLAGS_LEVEL_FATAL=4
-__FLAGS_LEVEL_DEFAULT=${FLAGS_LEVEL_WARN}
-
-# Determine some reasonable command defaults.
-_flags_expr_cmd() {
+# shlib_expr_cmd determines a reasonable default `expr` command.
+# https://github.com/kward/shlib
+#
+# Use like:
+#   EXPR_CMD=$(shlib_expr_cmd)
+#   ${EXPR_CMD} 1 + 1
+#
+# Args:
+#   none
+# Output:
+#   string: expr command
+# Return
+#   int: 0 upon success
+shlib_expr_cmd() {
   if [ "$(uname -s)" = 'BSD' ]; then
     echo 'gexpr --'
     return 0
   fi
 
-  _flags_expr_cmd_='expr --'
+  _shlib_expr_cmd_='expr --'
   # shellcheck disable=SC2003
-  if _flags_output_=$(expr -- 2>&1); then
-    if [ "${_flags_output_}" = '--' ]; then
+  if _shlib_output_=$(${_shlib_expr_cmd_} 2>&1); then
+    if [ "${_shlib_output_}" = '--' ]; then
       # We are likely running inside BusyBox.
-      _flags_expr_cmd_='expr'
+      _shlib_expr_cmd_='expr'
     fi
   fi
 
-  echo "${_flags_expr_cmd_}"
-  unset _flags_expr_cmd_ _flags_output_
+  echo "${_shlib_expr_cmd_}"
+  unset _shlib_expr_cmd_ _shlib_output_
 }
-__FLAGS_EXPR_CMD=`_flags_expr_cmd`
+__FLAGS_EXPR_CMD=`shlib_expr_cmd`
 
 # Commands a user can override if desired.
 FLAGS_EXPR_CMD=${FLAGS_EXPR_CMD:-${__FLAGS_EXPR_CMD}}
@@ -136,26 +140,28 @@ FLAGS_GETOPT_CMD=${FLAGS_GETOPT_CMD:-getopt}
 # Logging functions.
 #
 
-__flags_level=0 # Default logging level.
+# Logging levels.
+FLAGS_LEVEL_DEBUG=0
+FLAGS_LEVEL_INFO=1
+FLAGS_LEVEL_WARN=2
+FLAGS_LEVEL_ERROR=3
+FLAGS_LEVEL_FATAL=4
+__FLAGS_LEVEL_DEFAULT=${FLAGS_LEVEL_WARN}
+__flags_level=${__FLAGS_LEVEL_DEFAULT} # Current logging level.
 
 _flags_debug() {
-  [ ${__flags_level} -le ${FLAGS_LEVEL_DEBUG} ] || return
-  echo "flags:DEBUG $*" >&2
+  if [ ${__flags_level} -le ${FLAGS_LEVEL_DEBUG} ]; then echo "flags:DEBUG $*" >&2; fi
 }
 _flags_info() {
-  [ ${__flags_level} -le ${FLAGS_LEVEL_INFO} ] || return
-  echo "flags:INFO $*" >&2
+  if [ ${__flags_level} -le ${FLAGS_LEVEL_INFO} ]; then echo "flags:INFO $*" >&2; fi
 }
 _flags_warn() {
-  [ ${__flags_level} -le ${FLAGS_LEVEL_WARN} ] || return
-  echo "flags:WARN $*" >&2
+  if [ ${__flags_level} -le ${FLAGS_LEVEL_WARN} ]; then echo "flags:WARN $*" >&2; fi
 }
 _flags_error() {
-  [ ${__flags_level} -le ${FLAGS_LEVEL_ERROR} ] || return
-  echo "flags:ERROR $*" >&2
+  if [ ${__flags_level} -le ${FLAGS_LEVEL_ERROR} ]; then echo "flags:ERROR $*" >&2; fi
 }
 _flags_fatal() {
-  [ ${__flags_level} -le ${FLAGS_LEVEL_FATAL} ] || return
   echo "flags:FATAL $*" >&2
   exit ${FLAGS_ERROR}
 }
@@ -163,7 +169,7 @@ _flags_fatal() {
 # Get the logging level.
 flags_loggingLevel() { echo ${__flags_level}; }
 
-# Set the logging level.
+# Set the logging level by overriding the `__flags_level` variable.
 #
 # Args:
 #   _flags_level_: integer: new logging level
@@ -172,9 +178,9 @@ flags_loggingLevel() { echo ${__flags_level}; }
 flags_setLoggingLevel() {
   [ $# -ne 1 ] && _flags_fatal "flags_setLevel(): logging level missing"
   _flags_level_=$1
-  [ "${_flags_level_}" -ge "${FLAGS_LEVEL_DEBUG}" \
-    -a "${_flags_level_}" -le "${FLAGS_LEVEL_FATAL}" ] \
-      || _flags_fatal "Invalid logging level '${_flags_level_}' specified."
+  if ! [ "${_flags_level_}" -ge "${FLAGS_LEVEL_DEBUG}" -a "${_flags_level_}" -le "${FLAGS_LEVEL_FATAL}" ]; then
+    _flags_fatal "Invalid logging level '${_flags_level_}' specified."
+  fi
   __flags_level=$1
   unset _flags_level_
 }
@@ -327,8 +333,7 @@ _flags_define() {
   _flags_usName_="`_flags_underscoreName "${_flags_name_}"`"
 
   # Check whether the flag name is reserved.
-  _flags_itemInList "${_flags_usName_}" "${__FLAGS_RESERVED_LIST}"
-  if [ $? -eq ${FLAGS_TRUE} ]; then
+  if _flags_itemInList "${_flags_usName_}" "${__FLAGS_RESERVED_LIST}"; then
     flags_error="flag name (${_flags_name_}) is reserved"
     _flags_return_=${FLAGS_ERROR}
   fi
-- 
cgit v1.2.3


From 77a6d9e2425071609c843751f83b2eaca5c9a06a Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Fri, 10 Apr 2020 14:30:13 +0200
Subject: Fixed 'set -e' errors.

---
 shflags | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index da09932..35fb137 100644
--- a/shflags
+++ b/shflags
@@ -357,9 +357,7 @@ _flags_define() {
   fi
 
   # Check for existing short name definition.
-  if [ ${_flags_return_} -eq ${FLAGS_TRUE} \
-      -a "${_flags_short_}" != "${__FLAGS_NULL}" ]
-  then
+  if [ ${_flags_return_} -eq ${FLAGS_TRUE} -a "${_flags_short_}" != "${__FLAGS_NULL}" ]; then
     if _flags_itemInList "${_flags_short_}" "${__flags_shortNames}"; then
       flags_error="flag short name (${_flags_short_}) already defined"
       _flags_warn "${flags_error}"
-- 
cgit v1.2.3


From c825973613811b3be4fb963da6d72669805cef9e Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Sat, 11 Apr 2020 20:22:47 +0200
Subject: More set -e fixes.

---
 shflags | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 35fb137..21deb56 100644
--- a/shflags
+++ b/shflags
@@ -1002,8 +1002,9 @@ DEFINE_string()  { _flags_define ${__FLAGS_TYPE_STRING} "$@"; }
 #   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'
+  if [ -z "${__flags_help_type:-}" ]; then
+    DEFINE_boolean 'help' false 'show this help' 'h'
+  fi
 
   # Parse options.
   if [ $# -gt 0 ]; then
@@ -1024,7 +1025,9 @@ FLAGS() {
     flags_return=$?
   fi
 
-  [ ${flags_return} -eq ${FLAGS_ERROR} ] && _flags_fatal "${flags_error}"
+  if [ ${flags_return} -eq ${FLAGS_ERROR} ]; then
+    _flags_fatal "${flags_error}"
+  fi
   return ${flags_return}
 }
 
-- 
cgit v1.2.3


From 191e13bd68e7f9ce9163d25d6f1cabe4a0782369 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Mon, 13 Apr 2020 22:56:45 +0200
Subject: Fixed #50. FLAGS_ARGC is no longer exported. Started 1.4.0pre series.

---
 shflags | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index 21deb56..b42e607 100644
--- a/shflags
+++ b/shflags
@@ -92,7 +92,7 @@
 
 # Return if FLAGS already loaded.
 if [ -n "${FLAGS_VERSION:-}" ]; then return 0; fi
-FLAGS_VERSION='1.2.4pre'
+FLAGS_VERSION='1.4.0pre'
 
 # Return values that scripts can use.
 FLAGS_TRUE=0
@@ -770,7 +770,6 @@ _flags_parseGetopt() {
   # arguments. Its usage was replaced by FLAGS_ARGV, and it is being kept only
   # for backwards compatibility reasons.
   FLAGS_ARGC=`_flags_math "$# - 1 - ${_flags_argc_}"`
-  export FLAGS_ARGC
 
   # Handle options. note options with values must do an additional shift.
   while true; do
-- 
cgit v1.2.3


From 74f3040efe288aefa368fe4ef9025e15dafefcd8 Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Mon, 13 Apr 2020 23:00:19 +0200
Subject: Fixed a couple of potential set -e stragglers.

---
 shflags | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index b42e607..c39e6b4 100644
--- a/shflags
+++ b/shflags
@@ -466,7 +466,9 @@ _flags_genOptStr() {
   for _flags_name_ in ${__flags_longNames}; do
     _flags_usName_="`_flags_underscoreName "${_flags_name_}"`"
     _flags_type_="`_flags_getFlagInfo "${_flags_usName_}" "${__FLAGS_INFO_TYPE}"`"
-    [ $? -eq ${FLAGS_TRUE} ] || _flags_fatal 'call to _flags_type_ failed'
+    if [ $? -ne ${FLAGS_TRUE} ]; then
+      _flags_fatal 'call to _flags_type_ failed'
+    fi
     case ${_flags_optStrType_} in
       ${__FLAGS_OPTSTR_SHORT})
         _flags_shortName_="`_flags_getFlagInfo \
@@ -625,7 +627,9 @@ _flags_validBool() {
 #   bool: true if the value is a valid integer
 _flags_validFloat() {
   flags_return=${FLAGS_FALSE}
-  [ -n "$1" ] || return ${flags_return}
+  if [ -z "$1" ]; then
+    return ${flags_return}
+  fi
   _flags_float_=$1
 
   if _flags_validInt "${_flags_float_}"; then
-- 
cgit v1.2.3


From 46e081ec6e08313e4f0f314feee6650fe44eabfc Mon Sep 17 00:00:00 2001
From: Kate Ward <kate.ward@forestent.com>
Date: Mon, 13 Apr 2020 23:51:43 +0200
Subject: Removed FLAGS_ARGC harder.

---
 shflags | 17 +++--------------
 1 file changed, 3 insertions(+), 14 deletions(-)

(limited to 'shflags')

diff --git a/shflags b/shflags
index c39e6b4..5cfab3b 100644
--- a/shflags
+++ b/shflags
@@ -213,7 +213,7 @@ fi
 #
 
 # Reserved flag names.
-__FLAGS_RESERVED_LIST=' ARGC ARGV ERROR FALSE GETOPT_CMD HELP PARENT TRUE '
+__FLAGS_RESERVED_LIST=' ARGV ERROR FALSE GETOPT_CMD HELP PARENT TRUE '
 __FLAGS_RESERVED_LIST="${__FLAGS_RESERVED_LIST} VERSION "
 
 # Determined getopt version (standard or enhanced).
@@ -749,14 +749,10 @@ _flags_getoptEnhanced() {
 # 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
-  shift
-
   flags_return=${FLAGS_TRUE}
 
   if [ "${__FLAGS_GETOPT_VERS}" -ne "${__FLAGS_GETOPT_VERS_ENH}" ]; then
@@ -764,17 +760,10 @@ _flags_parseGetopt() {
     #   shellcheck disable=SC2068
     set -- $@
   else
-    # Note the quotes around the `$@' -- they are essential!
+    # Note the quotes around the `$@` -- they are essential!
     eval set -- "$@"
   fi
 
-  # Provide user with the 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=`_flags_math "$# - 1 - ${_flags_argc_}"`
-
   # Handle options. note options with values must do an additional shift.
   while true; do
     _flags_opt_=$1
@@ -1024,7 +1013,7 @@ FLAGS() {
   fi
 
   if [ ${flags_return} -eq ${FLAGS_TRUE} ]; then
-    _flags_parseGetopt $# "${__flags_opts}"
+    _flags_parseGetopt "${__flags_opts}"
     flags_return=$?
   fi
 
-- 
cgit v1.2.3