separate parsing routines for standard and enhanced getopt (easier to test), and started applying the new coding standards
diff --git a/source/1.0/src/shflags b/source/1.0/src/shflags
index 0631a80..bc3a10d 100644
--- a/source/1.0/src/shflags
+++ b/source/1.0/src/shflags
@@ -1,3 +1,6 @@
+# $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)
#
@@ -17,8 +20,8 @@
# 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=1 or
-# --myflag=false or --myflag=f or --myflag=0
+# --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
@@ -55,6 +58,8 @@
# __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
@@ -174,6 +179,8 @@
__flags_longNames=' '
__flags_shortNames=' '
+__flags_opts=''
+
#------------------------------------------------------------------------------
# private functions
#
@@ -203,113 +210,113 @@
return ${flags_return}
fi
- _flags__type=$1
- _flags__name=$2
- _flags__default=$3
- _flags__help=$4
- _flags__short=${5:-${__FLAGS_NULL}}
+ _flags_type_=$1
+ _flags_name_=$2
+ _flags_default_=$3
+ _flags_help_=$4
+ _flags_short_=${5:-${__FLAGS_NULL}}
- _flags__return=${FLAGS_TRUE}
+ _flags_return_=${FLAGS_TRUE}
# TODO(kward): check for validity of the flag name (e.g. dashes)
# TODO(kward): throw warning when a flag without a short name is defined on a
# system with a standard getopt
# require short option for getopt that don't support long options
- if [ ${_flags__return} -eq ${FLAGS_TRUE} \
+ if [ ${_flags_return_} -eq ${FLAGS_TRUE} \
-a ${__FLAGS_GETOPT_VERS} -ne ${__FLAGS_GETOPT_VERS_ENH} \
- -a "${_flags__short}" = "${__FLAGS_NULL}" ]
+ -a "${_flags_short_}" = "${__FLAGS_NULL}" ]
then
flags_error="getopt on this platform supports only short flags. Please \
-declare one for the (${_flags__name}) flag."
- _flags__return=${FLAGS_ERROR}
+declare one for the (${_flags_name_}) flag."
+ _flags_return_=${FLAGS_ERROR}
fi
# check for existing long name definition
- if [ ${_flags__return} -eq ${FLAGS_TRUE} ]; then
- if _flags_itemInList "${_flags__name}" \
+ if [ ${_flags_return_} -eq ${FLAGS_TRUE} ]; then
+ if _flags_itemInList "${_flags_name_}" \
${__flags_longNames} ${__flags_boolNames}
then
- flags_error="flag name ([no]${_flags__name}) already defined"
+ flags_error="flag name ([no]${_flags_name_}) already defined"
_flags_warn "${flags_error}"
- _flags__return=${FLAGS_FALSE}
+ _flags_return_=${FLAGS_FALSE}
fi
fi
# check for existing short name definition
- if [ ${_flags__return} -eq ${FLAGS_TRUE} \
- -a "${_flags__short}" != "${__FLAGS_NULL}" ]
+ 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"
+ 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}
+ _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
+ if [ ${_flags_return_} -eq ${FLAGS_TRUE} ]; then
+ case ${_flags_type_} in
${__FLAGS_TYPE_BOOLEAN})
- if _flags_validateBoolean "${_flags__default}"; then
- case ${_flags__default} in
- true|t|0) _flags__default=${FLAGS_TRUE} ;;
- false|f|1) _flags__default=${FLAGS_FALSE} ;;
+ if _flags_validateBoolean "${_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}
+ flags_error="invalid default flag value '${_flags_default_}'"
+ _flags_return_=${FLAGS_ERROR}
fi
;;
${__FLAGS_TYPE_FLOAT})
- if _flags_validateFloat "${_flags__default}"; then
+ if _flags_validateFloat "${_flags_default_}"; then
:
else
- flags_error="invalid default flag value '${_flags__default}'"
- _flags__return=${FLAGS_ERROR}
+ flags_error="invalid default flag value '${_flags_default_}'"
+ _flags_return_=${FLAGS_ERROR}
fi
;;
${__FLAGS_TYPE_INTEGER})
- if _flags_validateInteger "${_flags__default}"; then
+ if _flags_validateInteger "${_flags_default_}"; then
:
else
- flags_error="invalid default flag value '${_flags__default}'"
- _flags__return=${FLAGS_ERROR}
+ 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}
+ flags_error="unrecognized flag type '${_flags_type_}'"
+ _flags_return_=${FLAGS_ERROR}
;;
esac
fi
- if [ ${_flags__return} -eq ${FLAGS_TRUE} ]; then
+ if [ ${_flags_return_} -eq ${FLAGS_TRUE} ]; then
# store flag information
- eval "FLAGS_${_flags__name}='${_flags__default}'"
- eval "__flags_${_flags__name}_${__FLAGS_INFO_TYPE_STR}=${_flags__type}"
- eval "__flags_${_flags__name}_${__FLAGS_INFO_DEFAULT_STR}=\
-\"${_flags__default}\""
- eval "__flags_${_flags__name}_${__FLAGS_INFO_HELP_STR}=\"${_flags__help}\""
- eval "__flags_${_flags__name}_${__FLAGS_INFO_SHORT_STR}='${_flags__short}'"
+ eval "FLAGS_${_flags_name_}='${_flags_default_}'"
+ eval "__flags_${_flags_name_}_${__FLAGS_INFO_TYPE_STR}=${_flags_type_}"
+ eval "__flags_${_flags_name_}_${__FLAGS_INFO_DEFAULT_STR}=\
+\"${_flags_default_}\""
+ eval "__flags_${_flags_name_}_${__FLAGS_INFO_HELP_STR}=\"${_flags_help_}\""
+ eval "__flags_${_flags_name_}_${__FLAGS_INFO_SHORT_STR}='${_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} ] && \
- __flags_boolNames="${__flags_boolNames}no${_flags__name} "
+ __flags_longNames="${__flags_longNames}${_flags_name_} "
+ __flags_shortNames="${__flags_shortNames}${_flags_short_} "
+ [ ${_flags_type_} -eq ${__FLAGS_TYPE_BOOLEAN} ] && \
+ __flags_boolNames="${__flags_boolNames}no${_flags_name_} "
fi
- flags_return=${_flags__return}
- unset _flags__default _flags__help _flags__name _flags__return _flags__short \
- _flags__type
+ flags_return=${_flags_return_}
+ unset _flags_default_ _flags_help_ _flags_name_ _flags_return_ _flags_short_ \
+ _flags_type_
[ ${flags_return} -eq ${FLAGS_ERROR} ] && _flags_error "${flags_error}"
return ${flags_return}
}
@@ -437,16 +444,16 @@
# bool: true if the value is a valid boolean
_flags_validateBoolean()
{
- _flags__bool=$1
+ _flags_bool_=$1
flags_return=${FLAGS_TRUE}
- case ${_flags__bool} in
+ case "${_flags_bool_}" in
true|t|0) ;;
false|f|1) ;;
*) flags_return=${FLAGS_FALSE} ;;
esac
- unset _flags__bool
+ unset _flags_bool_
return ${flags_return}
}
@@ -504,6 +511,189 @@
return ${flags_return}
}
+_flags_standardGetopt()
+{
+ flags_return=${FLAGS_TRUE}
+ _flags_shortOpts_=`_flags_genOptStr ${__FLAGS_OPTSTR_SHORT}`
+
+ # check for spaces in passed options
+ for _flags_opt_ in "$@"; do
+ _flags_match_=`echo "${_flags_opt_}" |sed 's/ //g'`
+ if [ "${_flags_match_}" != "${_flags_opt_}" ]; 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`
+ if [ $? -ne ${FLAGS_TRUE} ]; then
+ # TODO(kward): actually output the failed value
+ _flags_warn 'getopt on this platform supports only short flags.'
+ flags_error='unable to parse provided options with getopt.'
+ flags_return=${FLAGS_ERROR}
+ fi
+ fi
+
+ unset _flags_match_ _flags_opt_ _flags_shortOpts_
+ return ${flags_return}
+}
+
+_flags_enhancedGetopt()
+{
+ 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=`getopt \
+ -o ${_flags_shortOpts_} \
+ -l "${_flags_longOpts_},${_flags_boolOpts_}" \
+ -- "$@" 2>&1`
+ if [ $? -ne ${FLAGS_TRUE} ]; then
+ # TODO(kward): actually output the failed value
+ flags_error='unable to parse provided options with getopt.'
+ flags_return=${FLAGS_ERROR}
+ fi
+
+ unset _flags_boolOpts_ _flags_longOpts_ _flags_shortOpts_
+ return ${flags_return}
+}
+
+_flags_parseGetopt()
+{
+ FLAGS_ARGC=0
+ 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
+
+ # 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}
+
+ # determine long flag name
+ case "${_flags_opt_}" in
+ --) shift; break ;; # discontinue option parsing
+
+ --*) # 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}
+ _flags_arg_=${__FLAGS_NULL}
+ fi
+ 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_}`
+ _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
+
+ # handle special case help flag
+ if [ "${_flags_name_}" = 'help' ]; then
+ flags_help
+ flags_error='help requested'
+ flags_return=${FLAGS_FALSE}
+ break
+ fi
+
+ # set new flag value
+ [ ${_flags_type_} -eq ${__FLAGS_TYPE_NONE} ] && \
+ _flags_type_=`_flags_getFlagInfo \
+ "${_flags_name_}" ${__FLAGS_INFO_TYPE_STR}`
+ case ${_flags_type_} in
+ ${__FLAGS_TYPE_BOOLEAN})
+ if [ ${_flags_len_} -eq ${__FLAGS_LEN_LONG} ]; then
+ if [ "${_flags_arg_}" != "${__FLAGS_NULL}" ]; then
+ eval "FLAGS_${_flags_name_}=${FLAGS_TRUE}"
+ else
+ eval "FLAGS_${_flags_name_}=${FLAGS_FALSE}"
+ fi
+ else
+ _flags_strToEval_="_flags_val_=\
+\${__flags_${_flags_name_}_${__FLAGS_INFO_DEFAULT_STR}}"
+ eval "${_flags_strToEval_}"
+ if [ ${_flags_val_} -eq ${FLAGS_FALSE} ]; then
+ eval "FLAGS_${_flags_name_}=${FLAGS_TRUE}"
+ else
+ eval "FLAGS_${_flags_name_}=${FLAGS_FALSE}"
+ fi
+ fi
+ ;;
+
+ ${__FLAGS_TYPE_FLOAT})
+ if _flags_validateFloat "${_flags_arg_}"; then
+ eval "FLAGS_${_flags_name_}='${_flags_arg_}'"
+ else
+ flags_error="invalid float value (${_flags_arg_})"
+ flags_return=${FLAGS_ERROR}
+ break
+ fi
+ ;;
+
+ ${__FLAGS_TYPE_INTEGER})
+ if _flags_validateInteger "${_flags_arg_}"; then
+ eval "FLAGS_${_flags_name_}='${_flags_arg_}'"
+ else
+ flags_error="invalid integer value (${_flags_arg_})"
+ flags_return=${FLAGS_ERROR}
+ break
+ fi
+ ;;
+
+ ${__FLAGS_TYPE_STRING})
+ eval "FLAGS_${_flags_name_}='${_flags_arg_}'"
+ ;;
+ esac
+
+ # shift the option out
+ shift
+ FLAGS_ARGC=`expr ${FLAGS_ARGC} + 1`
+
+ # additional shift for the argument
+ if [ ${_flags_type_} != ${__FLAGS_TYPE_BOOLEAN} ]; then
+ shift
+ FLAGS_ARGC=`expr ${FLAGS_ARGC} + 1`
+ fi
+ done
+
+ unset _flags_arg_ _flags_len_ _flags_name_ _flags_opt_ _flags_pos_ \
+ _flags_strToEval_ _flags_type_ _flags_val_
+ return ${flags_return}
+}
+
#------------------------------------------------------------------------------
# public functions
#
@@ -536,176 +726,23 @@
# integer: success of operation, or error
FLAGS()
{
- _flags_return=${FLAGS_TRUE}
-
# define standard 'help' flag
DEFINE_boolean 'help' false 'show this help' 'h'
- FLAGS_ARGC=0
- _flags_shortOpts=`_flags_genOptStr ${__FLAGS_OPTSTR_SHORT}`
- _flags_longOpts='' # generated later only when needed
-
# parse options
# TODO(kward): look into '-T' option to test the internal getopt() version
if [ ${__FLAGS_GETOPT_VERS} -ne ${__FLAGS_GETOPT_VERS_ENH} ]; then
- # check for spaces in passed options
- for _flags_opt in "$@"; do
- _flags_match=`echo "${_flags_opt}" |sed 's/ //g'`
- if [ "${_flags_match}" != "${_flags_opt}" ]; then
- _flags_error 'the available getopt does not support spaces in options'
- return ${FLAGS_ERROR}
- fi
- done
- unset _flags_match
-
- _flags_opts=`getopt ${_flags_shortOpts} $@ 2>&1`
+ _flags_standardGetopt "$@"
else
- _flags_boolOpts=`echo "${__flags_boolNames}" \
- |sed 's/^ *//;s/ *$//;s/ /,/g'`
-
- _flags_longOpts=`_flags_genOptStr ${__FLAGS_OPTSTR_LONG}`
- _flags_longOpts="${_flags_longOpts},${_flags_boolOpts}"
-
- _flags_opts=`getopt \
- -o ${_flags_shortOpts} \
- -l ${_flags_longOpts} \
- -- "$@" 2>&1`
+ _flags_enhancedGetopt "$@"
fi
- if [ $? -ne 0 ]; then
- _flags_warn 'getopt on this platform supports only short flags.'
- flags_error='unable to parse provided options with getopt.'
- _flags_return=${FLAGS_ERROR}
+ flags_return=$?
+
+ if [ ${flags_return} -eq ${FLAGS_TRUE} ]; then
+ _flags_parseGetopt "${__flags_opts}"
+ flags_return=$?
fi
- # output the options
- if [ ${_flags_return} -eq ${FLAGS_TRUE} ]; then
- if [ ${__FLAGS_GETOPT_VERS} -ne ${__FLAGS_GETOPT_VERS_ENH} ]; then
- set -- ${_flags_opts}
- else
- # note the quotes around the `${_flags_opts}' -- they are essential!
- eval set -- "${_flags_opts}"
- 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}
-
- # determine long flag name
- case "${_flags_opt}" in
- --) shift; break ;; # discontinue option parsing
-
- --*) # 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}
- _flags_arg=${__FLAGS_NULL}
- fi
- 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}`
- _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
-
- # handle special case help flag
- if [ "${_flags_name}" = 'help' ]; then
- flags_help
- flags_error='help requested'
- _flags_return=${FLAGS_FALSE}
- break
- fi
-
- # set new flag value
- [ ${_flags_type} -eq ${__FLAGS_TYPE_NONE} ] && \
- _flags_type=`_flags_getFlagInfo \
- "${_flags_name}" ${__FLAGS_INFO_TYPE_STR}`
- case ${_flags_type} in
- ${__FLAGS_TYPE_BOOLEAN})
- if [ ${_flags_len} -eq ${__FLAGS_LEN_LONG} ]; then
- if [ "${_flags_arg}" != "${__FLAGS_NULL}" ]; then
- eval "FLAGS_${_flags_name}=${FLAGS_TRUE}"
- else
- eval "FLAGS_${_flags_name}=${FLAGS_FALSE}"
- fi
- else
- _flags_strToEval="_flags_val=\
-\${__flags_${_flags_name}_${__FLAGS_INFO_DEFAULT_STR}}"
- eval "${_flags_strToEval}"
- if [ ${_flags_val} -eq ${FLAGS_FALSE} ]; then
- eval "FLAGS_${_flags_name}=${FLAGS_TRUE}"
- else
- eval "FLAGS_${_flags_name}=${FLAGS_FALSE}"
- fi
- fi
- ;;
-
- ${__FLAGS_TYPE_FLOAT})
- if _flags_validateFloat "${_flags_arg}"; then
- eval "FLAGS_${_flags_name}='${_flags_arg}'"
- else
- flags_error="invalid float value (${_flags_arg})"
- _flags_return=${FLAGS_ERROR}
- break
- fi
- ;;
-
- ${__FLAGS_TYPE_INTEGER})
- if _flags_validateInteger "${_flags_arg}"; then
- eval "FLAGS_${_flags_name}='${_flags_arg}'"
- else
- flags_error="invalid integer value (${_flags_arg})"
- _flags_return=${FLAGS_ERROR}
- break
- fi
- ;;
-
- ${__FLAGS_TYPE_STRING})
- eval "FLAGS_${_flags_name}='${_flags_arg}'"
- ;;
- esac
-
- # shift the option out
- shift
- FLAGS_ARGC=`expr ${FLAGS_ARGC} + 1`
-
- # additional shift for the argument
- if [ ${_flags_type} != ${__FLAGS_TYPE_BOOLEAN} ]; then
- shift
- FLAGS_ARGC=`expr ${FLAGS_ARGC} + 1`
- fi
- done
- fi
-
- flags_return=${_flags_return}
- unset _flags_arg _flags_boolOpts _flags_len _flags_longOpts _flags_name \
- _flags_opt _flags_opts _flags_pos _flags_return _flags_shortOpts \
- _flags_strToEval _flags_type _flags_val
[ ${flags_return} -eq ${FLAGS_ERROR} ] && _flags_fatal "${flags_error}"
return ${flags_return}
}
@@ -716,6 +753,8 @@
#
# Args:
# none
+# Output:
+# debug info that can be included in a bug report
# Returns:
# nothing
flags_getoptInfo()
@@ -735,17 +774,19 @@
# getopt info
getopt >/dev/null
- _flags__getoptReturn=$?
- _flags_debug "getopt return: ${_flags__getoptReturn}"
+ _flags_getoptReturn=$?
+ _flags_debug "getopt return: ${_flags_getoptReturn}"
_flags_debug "getopt --version: `getopt --version 2>&1`"
- unset _flags__getoptReturn
+ 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()
@@ -802,12 +843,12 @@
_flags_type=`_flags_getFlagInfo \
"${_flags_name}" ${__FLAGS_INFO_TYPE_STR}`
- [ "${_flags_short}" != "${__FLAGS_NULL}" ] \
- && _flags_flagStr="${_flags_flagStr}-${_flags_short}"
+ [ "${_flags_short}" != "${__FLAGS_NULL}" ] && \
+ _flags_flagStr="${_flags_flagStr}-${_flags_short}"
if [ ${__FLAGS_GETOPT_VERS} -eq ${__FLAGS_GETOPT_VERS_ENH} ]; then
- [ "${_flags_short}" != "${__FLAGS_NULL}" ] \
- && _flags_flagStr="${_flags_flagStr},"
+ [ "${_flags_short}" != "${__FLAGS_NULL}" ] && \
+ _flags_flagStr="${_flags_flagStr},"
if [ ${_flags_type} -eq ${__FLAGS_TYPE_BOOLEAN} ]; then
_flags_boolStr='[no]'
else
@@ -887,6 +928,3 @@
|grep ${_flags_shellFlag} >/dev/null || set +${_flags_shellFlag}
done
unset _flags_oldShellFlags _flags_shellFlag
-
-# vim:et:ft=sh:sts=2:sw=2
-# $Id$