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