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