【shflags】

wxy.me

已于 2023-02-13 22:50:30 修改

阅读量204

点赞数

文章标签： bash linux

于 2023-02-06 20:45:03 首次发布

本文链接：https://blog.csdn.net/qq_41720266/article/details/128872480

版权

shFlags 是用于 Unix shell 的 Google gflags 库的一个端口。代码以尽可能可移植的方式编写，以跨各种 Unix 变体工作。它还使用 shUnit2 进行了测试以保持代码质量。

如果您想使用 shFlags，请随时阅读文档。
https://github.com/kward/shflags/wiki/Documentation12x
https://github.com/kward/shflags/wiki/Documentation13x

https://github.com/kward/shflags

#文件名: external/shflags/shflags:
# shFlags is an advanced command-line flag library for Unix shell scripts.
# shFlags是一个先进的Unix shell脚本命令行标志库
# 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.
#
# 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.
#FLAG TYPES: 这是你可以执行的 DEFINE_* 列表。 所有标志都有一个名称、默认值、帮助字符串 和 可选的“短”名称（一个字母的名称）。
# 一些标志有其他参数，用标志描述。
# 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.
#  不接受任何参数。 --myflag 将 FLAGS_myflag 设置为 true，或说 --nomyflag 将 FLAGS_myflag 设置为 false。
#  对于短标志，在命令行上传递标志会否定默认值，即如果默认值为 true，则传递标志会将值设置为 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.
# 接受输入并将其解释为浮点数。 由于 shell 本身不支持浮点数，因此仅将输入验证为有效的浮点值。
#
# 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) # 从 foo 读取标志。 （尚未实施）
#   --              as in getopt(), terminates flag-processing # 与 getopt() 一样，终止标志处理
#
# 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.
# 脚本可以通过定义 FLAGS_GETOPT_CMD 变量提供替代实现的路径来覆盖默认的“getopt”命令。
#
# NOTES:
#
# * Not all systems include a getopt version that supports long flags. On these
#   systems, only short flags are recognized.
# 并非所有系统都包含支持长标志的 getopt 版本。 在这些系统上，只能识别短标志。

#==============================================================================
# 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 getopt解析的选项
#
# Per-flag attributes: 每个标志属性
#   FLAGS_<flag_name>: contains value of flag named 'flag_name' 包含名为“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. # 字符串列表以空格分隔，空值是 '~' 字符。
#
### ShellCheck (http://www.shellcheck.net/)  # shellcheck -- shell脚本分析工具
# expr may be antiquated, but it is the only solution in some cases.  expr 可能过时了，但在某些情况下它是唯一的解决方案。
#   shellcheck disable=SC2003
# $() are not fully portable (POSIX != portable).   # $() 不是完全可移植的（POSIX != 可移植）。
#   shellcheck disable=SC2006
# [ p -a q ] are well defined enough (vs [ p ] && [ q ]). # [ p -a q ] 定义得很好（对比 [ p ] && [ q ]）。
#   shellcheck disable=SC2166

# Return if FLAGS already loaded.  # 如果 FLAGS 已经加载则返回
if [ -n "${FLAGS_VERSION:-}" ]; then return 0; fi
FLAGS_VERSION='1.4.0pre'

# Return values that scripts can use. # 脚本可以使用的返回值。
FLAGS_TRUE=0
FLAGS_FALSE=1
FLAGS_ERROR=2

# shlib_expr_cmd determines a reasonable default `expr` command.
# https://github.com/kward/shlib # 文件为functions/shlib_expr_cmd
#
# 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

  _shlib_expr_cmd_='expr --'
  # shellcheck disable=SC2003
  if _shlib_output_=$(${_shlib_expr_cmd_} 2>&1); then
    if [ "${_shlib_output_}" = '--' ]; then
      # We are likely running inside BusyBox.
      _shlib_expr_cmd_='expr'
    fi
  fi

  echo "${_shlib_expr_cmd_}"
  unset _shlib_expr_cmd_ _shlib_output_
}
__FLAGS_EXPR_CMD=`shlib_expr_cmd`

# Commands a user can override if desired.  # 如果需要，用户可以覆盖命令。
FLAGS_EXPR_CMD=${FLAGS_EXPR_CMD:-${__FLAGS_EXPR_CMD}}
FLAGS_GETOPT_CMD=${FLAGS_GETOPT_CMD:-getopt}

#
# Logging functions.  log函数
#

# Logging levels.  log级别
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}   #默认是warn级别
__flags_level=${__FLAGS_LEVEL_DEFAULT} # Current logging level. 当前的log级别

_flags_debug() {
  if [ ${__flags_level} -le ${FLAGS_LEVEL_DEBUG} ]; then echo "flags:DEBUG $*" >&2; fi
}
_flags_info() {
  if [ ${__flags_level} -le ${FLAGS_LEVEL_INFO} ]; then echo "flags:INFO $*" >&2; fi
}
_flags_warn() {
  if [ ${__flags_level} -le ${FLAGS_LEVEL_WARN} ]; then echo "flags:WARN $*" >&2; fi
}
_flags_error() {
  if [ ${__flags_level} -le ${FLAGS_LEVEL_ERROR} ]; then echo "flags:ERROR $*" >&2; fi
}
_flags_fatal() {
  echo "flags:FATAL $*" >&2
  exit ${FLAGS_ERROR}
}

# Get the logging level. 获取当前的log级别
flags_loggingLevel() { echo ${__flags_level}; }

# Set the logging level by overriding the `__flags_level` variable. 通过覆盖 __flags_level 变量来设置日志记录级别。
#
# Args:
#   _flags_level_: integer: new logging level  新的日志级别
# Returns:
#   nothing 
flags_setLoggingLevel() {
  [ $# -ne 1 ] && _flags_fatal "flags_setLevel(): logging level missing"
  _flags_level_=$1
  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_
}

#
# Shell checks.  shell检查
#

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=' ARGV ERROR FALSE GETOPT_CMD HELP PARENT TRUE '
__FLAGS_RESERVED_LIST="${__FLAGS_RESERVED_LIST} VERSION "

# Determined getopt version (standard or enhanced). 决定 getopt 版本（标准或增强）。
__FLAGS_GETOPT_VERS_STD=0
__FLAGS_GETOPT_VERS_ENH=1

# 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 # getopt 选项字符串长度：长选项 或者 短选项
__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}'`  
#将shell中当前设置的FLAGS_*和__FLAGS_*变量设置为只读
for __flags_const in ${__flags_constants}; do
  # Skip certain flags.  #跳过确定的标志：FLAGS_HELP, FLAGS_PARENT
  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}" ;;
    *)
      # Declare readonly constants globally.
      # shellcheck disable=SC2039
      readonly -g "${__flags_const}" ;;
  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_opts=''     # Temporary storage for parsed getopt flags.  已解析getopt标志的临时存储 

# 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_*) 标志类型（__FLAGS_type_* 其中之一）
#
# Args: 参数：
#   _flags_type_: integer: internal type of flag (__FLAGS_TYPE_*) 整数：标志的内部类型（__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  #参数个数必须要大于等于4

  _flags_type_=$1
  _flags_name_=$2
  _flags_default_=$3
  _flags_help_=${4:-§}  # Special value '§' indicates no help string provided.  特殊值“§”表示未提供帮助字符串。
  _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. 检查标志名是否预留。
  if _flags_itemInList "${_flags_usName_}" "${__FLAGS_RESERVED_LIST}"; 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. 为不支持长选项的getopt请求短选项。
  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/then/else的“if”部分只包含一个“：”，它什么都不做。没有通过“！”进行二进制反转，因为它不适用于所有外壳。
  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. shell中的任何内容都是一个有效的字符串

      *)
        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 z- z_
}

# 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}"`"
    if [ $? -ne ${FLAGS_TRUE} ]; then
      _flags_fatal 'call to _flags_type_ failed'
    fi
    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

  # 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_}" ]; 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
    # 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 ;-)
    #
    # 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_}"
    # shellcheck disable=SC2154
    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 ').
# 传递了一个字符串（例如“abc”），此函数将确定字符串列表中是否存在该字符串（例如，“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 如果项目在列表中返回true
_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
    if eval stty size >/dev/null 2>&1; then
      # stty size worked :-)
      # shellcheck disable=SC2046
      set -- `stty size`
      __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:-}"
    fi
  fi
  echo "${__flags_columns:-80}"
}

# Validate a boolean. 验证布尔值。
#
# Args:
#   _flags__bool: boolean: value to validate 布尔：要验证的值
# Returns:
#   bool: true if the value is a valid boolean 如果值是一个有效的布尔值，返回true
_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 如果值为有效整数，则为 true
_flags_validFloat() {
  flags_return=${FLAGS_FALSE}
  if [ -z "$1" ]; then
    return ${flags_return}
  fi
  _flags_float_=$1

  if _flags_validInt "${_flags_float_}"; then  #整数是特殊的浮点数
    flags_return=${FLAGS_TRUE}
  elif _flags_useBuiltin; then #使用shell内置的功能和整数验证方法来判断
    _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}
    fi
    unset _flags_float_whole_ _flags_float_fraction_
  else
    flags_return=${FLAGS_TRUE}
    case ${_flags_float_} in #使用expr -- STRING : REGEXP正则表达式匹配功能来判断
      -*)  # 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  如果该值是一个有效的整数返回true
_flags_validInt() {
  expr \( "$1" + '0' \) '=' "$1" >/dev/null 2>&1
}

# 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:
#   @: varies: output from getopt parsing
# Returns:
#   integer: a FLAGS success condition
_flags_parseGetopt() {
  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!
    eval set -- "$@"
  fi

  # 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_}"
          # shellcheck disable=SC2154
          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
      # shellcheck disable=SC2154
      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)).
    # 需要变量赋值作为 Solaris Bourne shell 的解决方法，它无法解析裸 $((表达式))。
    # shellcheck disable=SC2016
    _flags_expr_='$(($@))'
    eval echo ${_flags_expr_}
    flags_return=$?
    unset _flags_expr_
  else
    eval expr "$@"
    flags_return=$?
  fi

  return ${flags_return}
}

# Cross-platform strlen() implementation. 跨平台 strlen（） 实现。
#
# Args:
#   _flags_str: string: to determine length of 字符串：确定长度
# Output:
#   integer: length of string   #字符串的长度
# Returns:
#   bool: success of strlen evaluation   strlen评估是否成功
_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 如果应使用内置，则为 true
_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.
# 一个基本的布尔标志。布尔标志不接受任何参数，其值为 1（假）或 0（真）。对于长标志，在命令行上通过在单词“no”前面加上前缀来指定 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'.
# 例如，假设创建了一个布尔标志，其长名称为“update”，短名称为“x”，默认值为“false”。此标志可以使用“--update”或“-x”显式设置为“true”，也可以使用“--noupdate”显式设置为“false”。
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.
  # 定义一个标准的“帮助”标志（如果尚未定义）。
  if [ -z "${__flags_help_type:-}" ]; then
    DEFINE_boolean 'help' false 'show this help' 'h'
  fi

  # Parse options. 使用getopt命令解析命令行选项到__flags_opts里面。getopt有标准型和增强型两种
  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_*变量的值
    flags_return=$?
  fi

  if [ ${flags_return} -eq ${FLAGS_ERROR} ]; then
    _flags_fatal "${flags_error}"
  fi
  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_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. 将 shflags 重置回未初始化状态。
#
# 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. 设置默认log级别
flags_setLoggingLevel ${__FLAGS_LEVEL_DEFAULT}

一个例子：

#!/bin/sh

# source shflags 包含引用shflags文件
. ./shflags

write_date() { date >"$1"; }

# configure shflags
DEFINE_boolean 'force' false 'force overwriting' 'f'   #定义变量FLAGS_force
FLAGS_HELP="USAGE: $0 [flags] filename"  # 定义帮助信息

main() {
  # check for filename
  if [ $# -eq 0 ]; then
    echo 'error: filename missing' >&2
    flags_help #打印上面定义的FLAGS_HELP的信息，以及定义的force变量信息
    exit 1
  fi
  filename=$1

  if [ ! -f "${filename}" ]; then
    write_date "${filename}"
  else
    if [ ${FLAGS_force} -eq ${FLAGS_TRUE} ]; then
      write_date "${filename}"
    else
      echo 'warning: filename exists; not overwriting' >&2
      exit 2
    fi
  fi
}

# parse the command-line
FLAGS "$@" || exit $? #使用FLAGS函数解析命令行参数：-/--选项参数分配给FLAGS_*, 剩余参数分配给FLAGS_ARGV
eval set -- "${FLAGS_ARGV}"  #将解析的FLAGS_ARGV参数重新分配给$1,$2,$3...
main "$@"  #$@接受的就是上面的${FLAGS_ARGV}

测试1：

$ ./write_date.sh
error: filename missing
USAGE: ./write_date.sh [flags] filename
flags:
  -h  show this help #该选项默认定义在shflags中
  -f  force overwriting
$ echo $?
1

测试2：

$ ./write_date.sh junk.dat
$ cat junk.dat
Thu Jun 26 23:06:34 IST 2008

测试3：

$ ./write_date.sh junk.dat
warning: filename exists; not overwriting
$ echo $?
2

测试4：

$ ./write_date.sh -f junk.dat
$ cat junk.dat
Thu Jun 26 23:10:02 IST 2008

【shflags】

shFlags 是用于 Unix shell 的 Google gflags 库的一个端口。 代码以尽可能可移植的方式编写，以跨各种 Unix 变体工作。 它还使用 shUnit2 进行了测试以保持代码质量。

shFlags 是用于 Unix shell 的 Google gflags 库的一个端口。代码以尽可能可移植的方式编写，以跨各种 Unix 变体工作。它还使用 shUnit2 进行了测试以保持代码质量。