From 74e1b99aed9f14442e8110b6a934535860118ed3 Mon Sep 17 00:00:00 2001 From: luka Date: Thu, 12 Jun 2014 15:13:23 +0000 Subject: [PATCH] shflags: move to management feed Signed-off-by: Luka Perkov git-svn-id: svn://svn.openwrt.org/openwrt/packages@41166 3c298f89-4303-0410-b956-a3cf2f4a3e73 --- libs/shflags/Makefile | 49 -- libs/shflags/patches/000-strip.patch | 763 --------------------------- 2 files changed, 812 deletions(-) delete mode 100644 libs/shflags/Makefile delete mode 100644 libs/shflags/patches/000-strip.patch diff --git a/libs/shflags/Makefile b/libs/shflags/Makefile deleted file mode 100644 index 3af741cc5..000000000 --- a/libs/shflags/Makefile +++ /dev/null @@ -1,49 +0,0 @@ -# -# 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_REV:=133 -PKG_VERSION:=2012-06-11_r$(PKG_REV) -PKG_RELEASE=1.0.x - -PKG_SOURCE_PROTO:=svn -PKG_SOURCE_URL:=http://shflags.googlecode.com/svn/trunk -PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION) -PKG_SOURCE_VERSION:=$(PKG_REV) -PKG_SOURCE:=$(PKG_NAME)-$(PKG_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 deleted file mode 100644 index cb4275e3d..000000000 --- a/libs/shflags/patches/000-strip.patch +++ /dev/null @@ -1,763 +0,0 @@ ---- a/source/1.0/src/shflags -+++ b/source/1.0/src/shflags -@@ -1,91 +1,10 @@ --# $Id: shflags 132 2009-05-10 18:03:58Z kate.ward@forestent.com $ --# 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=' '