BashArgParse

#!/bin/bash
#Bash Argument Parser (BAP) v2.3.7
__BAP_IFLAGS=()
__BAP_FFLAGS=()
__BAP_SFLAGS=()
__BAP_BFLAGS=()
__BAP_POSARGS=()
__BAP_POSARGS_METAVARS=()
__BAP_NUM_POSARGS=0
__BAP_NUM_REQ_POSARGS=0
__BAP_IFLAGS_REQ=()
__BAP_FFLAGS_REQ=()
__BAP_SFLAGS_REQ=()
__BAP_IFLAGS_NUM=()
__BAP_FFLAGS_NUM=()
__BAP_SFLAGS_NUM=()
__BAP_BFLAGS_NUM=()
__BAP_ADD_HELP=false
__BAP_ADD_VERSION=false

__BAP_USAGE_LEN=0
__BAP_DESC_LEN=0
__BAP_EPILOG_LEN=0
__BAP_HELP_LEN=0
__BAP_HELP=""
__BAP_HELP_SUPPRESS=false
__BAP_PARAMS=()
__BAP_FLAG_LIST=""
__BAP_LONG_FLAG_LIST=""
__BAP_REQ_ARG_LIST=""
__BAP_GIVEN_REQ_ARG_LIST=""
__BAP_SHIFT_NUM=1
__BAP_ADDED_FLAG_HELP=false
__BAP_ADDED_POSARG_HELP=false
__BAP_FOUND_FLAG=false
__BAP_PRINT_HELP=false
__BAP_PRINT_VERSION=false
__BAP_BEGIN=false

__BAP_USE_SUBPARSERS=false
__BAP_SUBPARSER_CHOICES=""
__BAP_SUBPARSER=""

__BAP_SAVED_ARGS=""

trap "exit 1" TERM
__BAP_TOP_PID=$$

# SCRIPT OPTIONS ================================================================================
__BAP_NAME=""
__BAP_SUBNAME=""
__BAP_DESC=""
__BAP_EPILOG=""
__BAP_VERSION=""
__BAP_LINE_CAP=70

__BAP_PREFIX="-"

__BAP_USAGE=""
__BAP_PREUSAGE_LEN=0
# ===============================================================================================

function __die { echo "$__BAP_USAGE" >&2; echo $@ >&2; kill -s TERM $__BAP_TOP_PID; }
function __check_lists { 
	[[ $# -ne 2 ]] && __die "error: __check_lists() requires 2 arguments"
	local first=`cut -d / -f 1 <<< $1`
	local second=`cut -d / -f 2 <<< $1`
#	if [[ ! $first =~ ^$__BAP_PREFIX$__BAP_PREFIX ]]; then
	if ! egrep -q "^([$__BAP_PREFIX])\1" <<< $first; then
		[[ $__BAP_FLAG_LIST = *"${first:1}"* ]] && __die "error: duplicate flag $first"
		__BAP_FLAG_LIST="${first} $__BAP_FLAG_LIST"
	fi
#	if [[ $second =~ ^$__BAP_PREFIX$__BAP_PREFIX ]]; then
	if egrep -q "^([$__BAP_PREFIX])\1" <<< $second; then
		[[ $__BAP_LONG_FLAG_LIST = *"$second"* ]] && __die "error: duplicate long flag $second"
		__BAP_LONG_FLAG_LIST="$second $__BAP_LONG_FLAG_LIST"
	fi
	$2 && __BAP_REQ_ARG_LIST="$1 $__BAP_REQ_ARG_LIST"
}
function __add_help {
	[[ -z $1 ]] && __die "error: __add_help() requires 4-5 arguments for flags, 3 arguments for positional arguments"
	[[ -z $__BAP_USAGE ]] && __die "error: you must call \`bap_set_name \$0\` before adding arguments"
	
	local suppress=false
#	if [[ ${1:0:1} = "$__BAP_PREFIX" ]]; then
	if [[ $1 =~ ^[$__BAP_PREFIX] ]]; then
		[[ $# -lt 4 || $# -gt 5 ]] && __die "error: __add_help() requires 4-5 arguments for flags (got $#)"
		$__BAP_HELP_SUPPRESS || $__BAP_ADDED_FLAG_HELP || __BAP_HELP=$(printf "$__BAP_HELP\noptional arguments:")
		__BAP_ADDED_FLAG_HELP=true
		
		local helpstr=$(printf "\n  $1")
		[[ -z $4 ]] && local suppress=true
		local first=`cut -d / -f 1 <<< $1`
		local second=`cut -d / -f 2 <<< $1`
		local index=2
		
		$3 || local usagestr="["
		local usagestr="$usagestr$first"
#		[[ $first = $second && ! $first =~ ^$__BAP_PREFIX$__BAP_PREFIX ]] && local index=1
		[[ $first = $second ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $first && local index=1
		if [[ $2 -ne 0 ]]; then
			for i in $(eval echo "{1..$2}"); do
				if [[ -z $5 ]]; then
					local helpstr=$(printf "$helpstr `tr [a-z] [A-Z] <<< ${second:$index}`")
					local usagestr="$usagestr `tr [a-z] [A-Z] <<< ${second:$index}`"
					[[ $2 -ne 1 ]] && local helpstr=$(printf "$helpstr$i") && local usagestr="$usagestr$i"
				else
					local helpstr=$(printf "$helpstr `cut -d , -f $i <<< $5`")
					local usagestr="$usagestr `cut -d , -f $i <<< $5`"
				fi
			done
		fi
		local helpstr=$(printf "$helpstr:\n\t")
		__BAP_HELP_LEN=0
		for word in $4; do
			local num=${#word}
			if (( $__BAP_HELP_LEN + $num + 4 <= $__BAP_LINE_CAP )); then
				if (( $__BAP_HELP_LEN == 0 )); then
					local helpstr=$(printf "$helpstr$word")
					__BAP_HELP_LEN=$num
				else
					local helpstr=$(printf "$helpstr $word")
					(( __BAP_HELP_LEN += $num + 1 ))
				fi
			else
				local helpstr=$(printf "$helpstr\n\t$word")
				__BAP_HELP_LEN=$num
			fi
		done
		$3 || local usagestr="$usagestr]"
	else
		[[ $# -lt 3 || $# -gt 4 ]] && __die "error: __add_help() requires 3-4 arguments for positional arguments"
		if [[ $__BAP_NUM_POSARGS -ne $__BAP_NUM_REQ_POSARGS && $2 = true ]]; then
			__die "error: required positional arguments cannot follow after optional positional arguments"
		fi
		if ! $__BAP_USE_SUBPARSERS; then
			$__BAP_HELP_SUPPRESS || $__BAP_ADDED_POSARG_HELP || __BAP_HELP=$(printf "$__BAP_HELP\npositional arguments:")
		else
			$__BAP_HELP_SUPPRESS || $__BAP_ADDED_POSARG_HELP || __BAP_HELP=$(printf "$__BAP_HELP\nsubcommands:") 
		fi
		__BAP_ADDED_POSARG_HELP=true
		
		[[ -z $4 ]] && local argname=$1 || local argname=$4
		local helpstr=$(printf "\n  $argname:\n\t")
		[[ -z $3 ]] && local suppress=true
		__BAP_HELP_LEN=0
		for word in $3; do
			local num=${#word}
			if (( $__BAP_HELP_LEN + $num + 8 <= $__BAP_LINE_CAP )); then
				if (( $__BAP_HELP_LEN == 0 )); then
					local helpstr=$(printf "$helpstr$word")
					__BAP_HELP_LEN=$num
				else
					local helpstr=$(printf "$helpstr $word")
					(( __BAP_HELP_LEN = $num + 1 ))
				fi
			else
				local helpstr=$(printf "$helpstr\n\t$word")
				__BAP_HELP_LEN=$num
			fi
		done
		$2 && local usagestr=$argname || local usagestr="[$argname]"
	fi
	
	$__BAP_HELP_SUPPRESS || $suppress || __BAP_HELP=$(printf "$__BAP_HELP$helpstr")
	local num=$(( ${#usagestr} + 1 ))
	if (( $__BAP_PREUSAGE_LEN + $__BAP_USAGE_LEN + $num <= $__BAP_LINE_CAP || $__BAP_USAGE_LEN == 0 )); then
		(( __BAP_USAGE_LEN += $num ))
		__BAP_USAGE=$(printf "$__BAP_USAGE $usagestr")
	else
		__BAP_USAGE=$(printf "$__BAP_USAGE\\\n")
		for i in $(eval echo "{1..${__BAP_PREUSAGE_LEN}}"); do
			__BAP_USAGE=$(printf "$__BAP_USAGE ")
		done
		__BAP_USAGE=$(printf "$__BAP_USAGE $usagestr")
		__BAP_USAGE_LEN=$num
	fi
}

function __save_flag { # save_flag $arg $argval
	[[ $# -ne 2 ]] && __die "error: save_flag() requires 2 arguments"
	local first=`cut -d / -f 1 <<< $1`
	local second=`cut -d / -f 2 <<< $1`
	local index=2
#	[[ $first = $second ]] && [[ ! $first =~ ^$__BAP_PREFIX$__BAP_PREFIX ]] && local index=1
	[[ $first = $second ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $first && local index=1
	local name=`tr [a-z] [A-z] <<< ${second:$index}`
	local name=`tr - _ <<< $name`
	printf -v "__BAP_ARG_$name" "%s" "$2"
	__BAP_SAVED_ARGS="${__BAP_SAVED_ARGS}__BAP_ARG_$name "
}

function __save_sflag { # save_sflag $arg $index $argval
	[[ $# -ne 3 ]] && __die "error: save_sflag() requires 3 arguments"
	local first=`cut -d / -f 1 <<< $1`
	local second=`cut -d / -f 2 <<< $1`
	local index=2
#	[[ $first = $second ]] && [[ ! $first =~ ^$__BAP_PREFIX$__BAP_PREFIX ]] && local index=1
	[[ $first = $second ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $first && local index=1
	local name=`tr [a-z] [A-z] <<< ${second:$index}`
	local name=`tr - _ <<< $name`

	printf -v "__BAP_ARG_${name}_$2" "%s" "$3"
	printf -v "__BAP_ARG_NUM_$name" "%i" $(( $2 + 1 ))
	
	__BAP_SAVED_ARGS="${__BAP_SAVED_ARGS}__BAP_ARG_NUM_$name __BAP_ARG_${name}_$2 "
}

function __save_posarg { # save_posarg $arg $argval
	local name=`tr [a-z] [A-Z] <<< $1`
	local name=`tr - _ <<< $name`

	printf -v "__BAP_POSARG_$name" "%s" "$2"
	__BAP_SAVED_ARGS="${__BAP_SAVED_ARGS}__BAP_POSARG_$name "
}
# SCRIPT FUNCTIONS ==============================================================================
function bap_error { # bap_error (OR) bap_error $message (OR) bap_error $arg $message
	[[ $# -eq 0 ]] && __die "error"
	[[ $# -eq 1 ]] && __die "error: $1"
	[[ $1 = -* ]] && __die "error: argument $1: $2"
	local found=-1
	[[ ${#__BAP_POSARGS[@]} -ne 0 ]] && for i in $(eval echo "{0..$(( ${#__BAP_POSARGS[@]} - 1 ))}"); do 
		[[ $1 = ${__BAP_POSARGS[$i]} ]] && local found=$i
	done
	[[ $found -lt 0 ]] && __die "error: argument $1: $2" || __die "error: argument ${__BAP_POSARGS_METAVARS[$found]}: $2"
}

function bap_set_prefix { # bap_set_prefix $chars
	[[ $# -ne 1 ]] && bap_error "set_prefix() requires 1 argument"
	[[ $1 =~ [[:alnum:]] || $1 =~ [[:space:]] ]] && bap_error "set_prefix() can only take non-alphanumeric characters"
	__BAP_PREFIX="$1"
}

function bap_set_name { # bap_set_name $name
	[[ $# -ne 1 ]] && bap_error "set_name() requires 1 argument"
	__BAP_NAME=$(basename $1)
	__BAP_USAGE="usage: $__BAP_NAME"
	__BAP_PREUSAGE_LEN=${#__BAP_USAGE}
}

function bap_set_subname { # bap_set_subname $name-subcommand
	[[ $# -ne 1 ]] && bap_error "set_subname() requires 1 argument"
	#sed 's/\(.*\)\..*/\1/'
	local temp=$(basename $1 | sed "s/\(.*\)\..*/\1/")
	local name=$(basename $temp | rev | cut -d - -f2- | rev)
	local subname=$(basename $temp | rev | cut -d - -f1 | rev)
	
	if [[ -f $(dirname $0)/$name ]]; then
		__BAP_NAME="$name"
	elif [[ -f $(dirname $0)/$name.sh ]]; then
		__BAP_NAME="$name.sh"
	fi
	__BAP_SUBNAME="$__BAP_NAME $subname"
	__BAP_USAGE="usage: $__BAP_SUBNAME"
	__BAP_PREUSAGE_LEN=${#__BAP_USAGE}
}

function bap_get_name { # bap_get_name
	echo $__BAP_NAME
}

function bap_get_subname { # bap_get_subname
	echo $__BAP_SUBNAME
}

function bap_set_desc { # bap_set_desc $desc
	[[ $# -ne 1 ]] && bap_error "set_desc() requires 1 argument" 
	local descstring=$1
	__BAP_DESC=""
	__BAP_DESC_LEN=0
	for word in $descstring; do
		local num=${#word}
		if (( $__BAP_DESC_LEN + $num + 1 > $__BAP_LINE_CAP || $__BAP_DESC_LEN == 0 )); then
			__BAP_DESC=$(printf "$__BAP_DESC\n$word")
			(( __BAP_DESC_LEN = $num ))
		else
			__BAP_DESC=$(printf "$__BAP_DESC $word")
			(( __BAP_DESC_LEN += $num + 1 ))
		fi
	done
}

function bap_set_epilog { # bap_set_epilog $epilog
	[[ $# -ne 1 ]] && bap_error "set_epilog() requires 1 argument"
	local epilogstring=$1
	__BAP_EPILOG=""
	__BAP_EPILOG_LEN=0
	for word in $epilogstring; do
		local num=${#word}
		if (( $__BAP_EPILOG_LEN + $num + 1 > $__BAP_LINE_CAP || $__BAP_EPILOG_LEN == 0 )); then
			__BAP_EPILOG=$(printf "$__BAP_EPILOG\n$word")
			(( __BAP_EPILOG_LEN = $num ))
		else
			__BAP_EPILOG=$(printf "$__BAP_EPILOG $word")
			(( __BAP_EPILOG_LEN += $num + 1 ))
		fi
	done
}

function bap_set_line_cap { # bap_set_line_cap $num
	[[ -z $__BAP_USAGE ]] && bap_error "you must call \`bap_set_name \$0\` before setting the line cap"
	[[ $# -ne 1 ]] && bap_error "set_line_cap() requires 1 argument"
	[[ ! $1 =~ ^[0-9]+$ ]] && bap_error "invalid integer: '$1'"
	[[ $1 -lt $__BAP_PREUSAGE_LEN ]] && bap_error "line cap must be greater than $__BAP_PREUSAGE_LEN"
	__BAP_LINE_CAP=$1
}

function bap_set_help { # bap_set_help $helpstr
	__BAP_HELP="$helpstr"
	__BAP_HELP_SUPPRESS=true
}


function bap_get_usage { # bap_get_usage
	echo "$__BAP_USAGE"
}

function bap_get_help { # bap_get_help 
	echo "$__BAP_USAGE"
	[[ ! -z $__BAP_DESC ]] && echo "$__BAP_DESC"
	echo "$__BAP_HELP"
	[[ ! -z $__BAP_EPILOG ]] && echo "$__BAP_EPILOG"
}

function bap_add_help { # bap_add_help
	__BAP_ADD_HELP=true
	__check_lists "-h/--help" false
	__add_help "-h/--help" 0 false "print this help message and exit"
}

function bap_add_version { # bap_add_version $version
	[[ $# -ne 1 ]] && bap_error "add_version() requires 1 argument"
	__BAP_ADD_VERSION=true
	__check_lists "--version" false
	__add_help "--version" 0 false "print the version and exit"
	__BAP_VERSION="$1"
}

function bap_add_iflag { # bap_add_iflag $arg $nargs $required $message [$metavarlist]
	[[ $# -lt 4 ]] && bap_error "add_iflag() requires at least 4 arguments"
	[[ $# -gt 5 ]] && bap_error "add_iflag() requires no more than 5 arguments"
	[[ ! $1 =~ ^[$__BAP_PREFIX] ]] && bap_error "unrecognized iflag format: $1"
	__check_lists $1 $3
	__add_help "$@"
	__BAP_IFLAGS+=($1)
	__BAP_IFLAGS_NUM+=($2)
	__BAP_IFLAGS_REQ+=($3)
}

function bap_add_fflag { # bap_add_fflag $arg $nargs $required $message [$metavarlist]
	[[ $# -lt 4 ]] && bap_error "add_fflag() requires at least 4 arguments"
	[[ $# -gt 5 ]] && bap_error "add_fflag() requires no more than 5 arguments"
	[[ ! $1 =~ ^[$__BAP_PREFIX] ]] && bap_error "unrecognized fflag format: $1"
	__check_lists $1 $3
	__add_help "$@"
	__BAP_FFLAGS+=($1)
	__BAP_FFLAGS_NUM+=($2)
	__BAP_FFLAGS_REQ+=($3)
}

function bap_add_sflag { # bap_add_sflag $arg $nargs $required $message [$metavarlist]
	[[ $# -lt 4 ]] && bap_error "add_sflag() requires at least 4 arguments"
	[[ $# -gt 5 ]] && bap_error "add_sflag() requires no more than 5 arguments"
	[[ ! $1 =~ ^[$__BAP_PREFIX] ]] && bap_error "unrecognized sflag format: $1"
	__check_lists $1 $3
	__add_help "$@"
	__BAP_SFLAGS+=($1)
	__BAP_SFLAGS_NUM+=($2)
	__BAP_SFLAGS_REQ+=($3)
}

function bap_add_bflag { # add_bflag $arg $message
	[[ $# -ne 2 ]] && bap_error "add_bflag() requires 2 arguments"
	[[ ! $1 =~ ^[$__BAP_PREFIX] ]] && bap_error "unrecognized bflag format: $1"
	__check_lists $1 false
	__add_help $1 0 false "$2"
	__BAP_BFLAGS+=($1)
	__BAP_BFLAGS_REQ+=(false)
}

function bap_add_posarg { # add_posarg $arg $required $message [$metavar]
	[[ $# -lt 3 ]] && bap_error "add_posarg() requires at least 3 arguments"
	[[ $# -gt 4 ]] && bap_error "add_posarg() requires no more than 4 arguments"
	$__BAP_USE_SUBPARSERS && [[ $__BAP_NUM_POSARGS -ne 0 ]] && bap_error "scripts with subparsers cannot have positional arguments"
	(( __BAP_NUM_POSARGS++ ))
	$2 && (( __BAP_NUM_REQ_POSARGS++ ))
	__add_help "$@"
	__BAP_POSARGS+=($1)
	[[ -z $4 ]] && __BAP_POSARGS_METAVARS+=($1) || __BAP_POSARGS_METAVARS+=($4)
}

function bap_parse { # bap_parse "$@"
	$__BAP_USE_SUBPARSERS && __BAP_USAGE="$__BAP_USAGE ..."
	local only_posargs=false
	while (( "$#" )); do
		[[ $1 = "--" ]] && local only_posargs=true && shift && continue
		if $only_posargs || [[ ! $1 =~ ^[$__BAP_PREFIX] ]]; then
			__BAP_PARAMS+=("$1")
			$__BAP_USE_SUBPARSERS && break
		else
			if $__BAP_ADD_HELP; then
				local arg="-h/--help"
				local first=`cut -d / -f 1 <<< $arg`
				local second=`cut -d / -f 2 <<< $arg`
#				if [[ $1 = *"${first:1}"* && ! $1 =~ ^$__BAP_PREFIX$__BAP_PREFIX ]] || [[ $1 = $second ]]; then
				if ( [[ $1 = *"${first:1}"* ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $1 ) || [[ $1 = $second ]]; then
					__BAP_PRINT_HELP=true
					__BAP_FOUND_FLAG=true
				fi
			fi
			if $__BAP_ADD_VERSION; then
				local arg="--version"
#				if [[ $1 = *"${first:1}"* && ! $1 =~ ^$__BAP_PREFIX$__BAP_PREFIX ]] || [[ $1 = $second ]]; then
				if [[ ${1:2} = ${arg:2} ]]; then
					__BAP_PRINT_VERSION=true
					__BAP_FOUND_FLAG=true
				fi
			fi

			# STRING FLAGS
			for i in $(eval echo "{0..$(( ${#__BAP_SFLAGS[@]} - 1 ))}"); do
				[[ ${#__BAP_SFLAGS[@]} -eq 0 ]] && break
				local arg=${__BAP_SFLAGS[$i]}
				local nargs=${__BAP_SFLAGS_NUM[$i]}
				local required=${__BAP_SFLAGS_REQ[$i]}
				local argval=()
				local first=`cut -d / -f 1 <<< $arg`
				local second=`cut -d / -f 2 <<< $arg`
				local temp=${1%%${first:1}*}
#				if [[ $1 = *"${first:1}"* && ! $1 =~ ^$__BAP_PREFIX$__BAP_PREFIX ]]; then
				if [[ ${#temp} -ne ${#1}-1 && $1 = *"${first:1}"* ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $1; then
					[[ $nargs -ne 1 ]] && bap_error $arg "expected $nargs arguments"
					argval+=("`cut -d ${first:1} -f 2- <<< $1`")
					__BAP_FOUND_FLAG=true
					set -- "`cut -d ${first:1} -f 1 <<< $1`${first:1}" "${@:2}"
					[[ ${argval[0]} = *"h"* && ! "`cut -d ${first:1} -f 1 <<< $1`" = *"h"* ]] && PRINT_HELP=false
#				elif [[ $1 = *"${first:1}" && ! $1 =~ ^$__BAP_PREFIX$__BAP_PREFIX ]] || [[ $1 =~ ^$second ]]; then
				elif ( [[ $1 = *"${first:1}" ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $1 ) || [[ $1 = "$second"* ]]; then
					if [[ $nargs -eq 1 ]]; then
						argval+=("`cut -d = -f 2- <<< $1`")
						if [[ ${argval[0]} = $1 ]]; then
							[[ -z $2 ]] && bap_error $arg "expected one argument"
							__BAP_SHIFT_NUM=2
							argval[0]=$2
						fi
					else
						(( end = $nargs + 1 ))
						for i in $(eval echo "{2..$end}"); do
							[[ -z ${@:$i:1} ]] && bap_error $arg "expected $nargs arguments"
							argval+=("${@:$i:1}")
						done
						(( __BAP_SHIFT_NUM = $nargs + 1 ))
					fi
					__BAP_FOUND_FLAG=true
				fi
				[[ ${#argval[@]} -eq 0 ]] && continue
				$required && __BAP_GIVEN_REQ_ARG_LIST="$arg $__BAP_GIVEN_REQ_ARG_LIST"
				for j in $(eval echo "{0..$(( $nargs - 1 ))}"); do
					__save_sflag $arg $j "${argval[$j]}"
				done
			done

			# INT FLAGS
			for i in $(eval echo "{0..$(( ${#__BAP_IFLAGS[@]} - 1 ))}"); do
				[[ ${#__BAP_IFLAGS[@]} -eq 0 ]] && break
				local arg=${__BAP_IFLAGS[$i]}
				local nargs=${__BAP_IFLAGS_NUM[$i]}
				local required=${__BAP_IFLAGS_REQ[$i]}
				local argval=""
				local first=`cut -d / -f 1 <<< $arg`
				local second=`cut -d / -f 2 <<< $arg`
				local temp=${1%%${first:1}*}
#				if [[ $1 = *"${first:1}"* && ! $1 =~ ^$__BAP_PREFIX$__BAP_PREFIX ]]; then
				if [[ ${#temp} -ne ${#1}-1 && $1 = *"${first:1}"* ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $1; then
					[[ $nargs -ne 1 ]] && bap_error $arg "expected $nargs arguments"
					local argval=`cut -d ${first:1} -f 2- <<< $1`
					[[ ! $argval =~ ^[0-9]+$ ]] && bap_error $arg "invalid integer: '$argval'"
					__BAP_FOUND_FLAG=true
					set -- "`cut -d ${first:1} -f 1 <<< $1`${first:1}" "${@:2}"
#				elif [[ $1 = *"${first:1}" && ! $1 =~ ^$__BAP_PREFIX$__BAP_PREFIX ]] || [[ $1 =~ ^$second ]]; then
				elif ( [[ $1 = *"${first:1}" ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $1 ) || [[ $1 =~ "$second"* ]]; then
					if [[ $nargs -eq 1 ]]; then
						local argval=`cut -d = -f 2- <<< $1`
						if [[ $argval = $1 ]]; then
							[ -z $2 ] && bap_error $arg "expected one argument"
							__BAP_SHIFT_NUM=2
							local argval=$2
						fi
						[[ ! $argval =~ ^[0-9]+$ ]] && bap_error $arg "invalid integer: '$argval'"
					else
						local end=0
						(( end = $nargs + 1 ))
						for i in $(eval echo "{2..$end}"); do
							[[ -z ${@:$i:1} ]] && bap_error $arg "expected $nargs arguments"
							[[ ! ${@:$i:1} =~ ^[0-9]+$ ]] && bap_error $arg "invalid integer: '${@:$i:1}'"
							[[ -z $argval ]] && local argval="${@:$i:1}" || local argval="$argval ${@:$i:1}"
						done
						(( __BAP_SHIFT_NUM = $nargs + 1 ))
					fi
					__BAP_FOUND_FLAG=true
				fi
				[[ -z $argval ]] && continue
				$required && __BAP_GIVEN_REQ_ARG_LIST="$arg $__BAP_GIVEN_REQ_ARG_LIST"
				__save_flag $arg "$argval"
			done
			
			# FLOAT FLAGS
			for i in $(eval echo "{0..$(( ${#__BAP_FFLAGS[@]} - 1 ))}"); do
				[[ ${#__BAP_FFLAGS[@]} -eq 0 ]] && break
				local arg=${__BAP_FFLAGS[$i]}
				local nargs=${__BAP_FFLAGS_NUM[$i]}
				local required=${__BAP_FFLAGS_REQ[$i]}
				local argval=""
				local first=`cut -d / -f 1 <<< $arg`
				local second=`cut -d / -f 2 <<< $arg`
				local temp=${1%%${first:1}*}
#				if [[ $1 = *"${first:1}"* && ! $1 =~ ^$__BAP_PREFIX$__BAP_PREFIX ]]; then
				if [[ ${#temp} -ne ${#1}-1 && $1 = *"${first:1}"* ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $1; then
					[[ $nargs -ne 1 ]] && bap_error $arg "expected $nargs arguments"
					local argval=`cut -d ${first:1} -f 2 <<< $1`
					[[ ! $argval =~ ^[0-9]+([.][0-9]+)?$ ]] && bap_error $arg "invalid float: '$argval'"
					__BAP_FOUND_FLAG=true
					set -- "`cut -d ${first:1} -f 1 <<< $1`${first:1}" "${@:2}"
#				elif [[ $1 = *"${first:1}" && ! $1 =~ ^$__BAP_PREFIX$__BAP_PREFIX ]] || [[ $1 =~ ^$second ]]; then
				elif ( [[ $1 = *"${first:1}" ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $1 ) || [[ $1 =~ "$second"* ]]; then
					if [[ $nargs -eq 1 ]]; then
						local argval=`cut -d = -f 2- <<< $1`
						if [[ $argval = $1 ]]; then
							[ -z $2 ] && bap_error $arg "expected one argument"
							__BAP_SHIFT_NUM=2
							local argval=$2
						fi
						[[ ! $argval =~ ^[0-9]+([.][0-9]+)?$ ]] && bap_error $arg "invalid float: '$argval'"
					else
						local end=0
						(( end = $nargs + 1 ))
						for i in $(eval echo "{2..$end}"); do
							[[ -z ${@:$i:1} ]] && bap_error $arg "expected $nargs arguments"
							[[ ! ${@:$i:1} =~ ^[0-9]+([.][0-9]+)?$ ]] && bap_error $arg "invalid float: '${@:$i:1}'"
							[[ -z $argval ]] && local argval="${@:$i:1}" || local argval="$argval ${@:$i:1}"
						done
						(( __BAP_SHIFT_NUM = $nargs + 1 ))
					fi
					__BAP_FOUND_FLAG=true
				fi
				[[ -z $argval ]] && continue
				$required && __BAP_GIVEN_REQ_ARG_LIST="$arg $__BAP_GIVEN_REQ_ARG_LIST"
				__save_flag $arg "$argval"
			done
			
			# BOOL FLAGS
			for i in $(eval echo "{0..$(( ${#__BAP_BFLAGS[@]} - 1 ))}"); do
				[[ ${#__BAP_BFLAGS[@]} -eq 0 ]] && break
				local arg=${__BAP_BFLAGS[$i]}
				local nargs=${__BAP_BFLAGS_NUM[$i]}
				local required=${__BAP_BFLAGS_REQ[$i]}
				local argval=""
				local first=`cut -d / -f 1 <<< $arg`
				local second=`cut -d / -f 2 <<< $arg`
#				if [[ $1 = *"${first:1}"* && ! $1 =~ ^$__BAP_PREFIX$__BAP_PREFIX ]] || [[ $1 = $second ]]; then
				if ( [[ $1 = *"${first:1}"* ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $1 ) || [[ $1 =~ $second ]]; then
					local argval=true
					__BAP_FOUND_FLAG=true
				fi
				[[ -z $argval ]] && continue
				$required && __BAP_GIVEN_REQ_ARG_LIST="$arg $__BAP_GIVEN_REQ_ARG_LIST"
				__save_flag $arg "$argval"
			done
			
			[[ $__BAP_FOUND_FLAG = false ]] && bap_error "unrecognized argument: $1"
#			if [[ ${1:0:1} = "$__BAP_PREFIX" && ! ${1:0:2} = "$__BAP_PREFIX$__BAP_PREFIX" ]]; then
			if [[ $1 =~ ^[$__BAP_PREFIX] ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $1; then
				while read -n 1 char; do
					[ -z $char ] && continue
					local found_char=false
					for w in $__BAP_FLAG_LIST; do [ $w = ${1:0:1}$char ] && local found_char=true; done
					[[ $found_char = false ]] && bap_error "unrecognized arguments: $1"
				done <<< ${1:1}
			fi
		fi
		
		shift $__BAP_SHIFT_NUM
		__BAP_SHIFT_NUM=1
		__BAP_FOUND_FLAG=false
	done
	if $__BAP_PRINT_HELP; then
		echo "$__BAP_USAGE"
		[[ ! -z $__BAP_DESC ]] && echo "$__BAP_DESC"
		echo "$__BAP_HELP"
		[[ ! -z $__BAP_EPILOG ]] && echo "$__BAP_EPILOG"
		exit 0
	fi
	if $__BAP_PRINT_VERSION; then
		[[ -z $__BAP_VERSION ]] && bap_error "version string is empty"
		echo $__BAP_VERSION
		exit 0
	fi
	for req in $__BAP_REQ_ARG_LIST; do [[ $__BAP_GIVEN_REQ_ARG_LIST = *"$req"* ]] || bap_error $req "argument is required"; done
	[[ ${#__BAP_PARAMS[@]} -lt $__BAP_NUM_REQ_POSARGS ]] && bap_error "too few arguments"
	! $__BAP_USE_SUBPARSERS && [[ ${#__BAP_PARAMS[@]} -gt $__BAP_NUM_POSARGS ]] && bap_error "too many arguments"
	[[ ${#__BAP_PARAMS[@]} -ne 0 ]] && for i in $(eval echo "{0..$(( ${#__BAP_PARAMS[@]} - 1 ))}"); do 
		__save_posarg ${__BAP_POSARGS[$i]} "${__BAP_PARAMS[$i]}"
	done
	$__BAP_USE_SUBPARSERS && __BAP_SUBPARSER=$(bap_get_choice "subcommand" $__BAP_SUBPARSER_CHOICES)
}

function bap_get { # bap_get $arg (OR) bap_get $arg $i
	[[ $# -lt 1 ]] && bap_error "get() requires at least 1 argument"
	local arg="${1%\"}"
	local arg="${arg#\"}"
	if [[ $arg =~ ^- ]]; then
		local first=`cut -d / -f 1 <<< $arg`
		local second=`cut -d / -f 2 <<< $arg`
		local index=2
#		[[ $first = $second ]] && [[ ! $first =~ ^$__BAP_PREFIX$__BAP_PREFIX ]] && local index=1
		[[ $first = $second ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $first && local index=1
		local name=`tr [a-z] [A-z] <<< ${second:$index}`
		local name=`tr - _ <<< $name`
	
		local argname="__BAP_ARG_$name"
		local numname="__BAP_ARG_NUM_$name"
		local num=$2
		[[ ! -z "${!numname}" ]] && [[ $# -ne 2 ]] && local num=0
		local argname_str="${argname}_$num"
		[[ -z "${!numname}" ]] && echo "${!argname}" || echo "${!argname_str}"
	else
		local name=`tr [a-z] [A-Z] <<< $arg`
		local name=`tr - _ <<< $name`

		local argname="__BAP_POSARG_$name"
		echo "${!argname}"
	fi
}

function bap_get_len { # bap_get_len $arg
	[[ $# -ne 1 ]] && bap_error "get_len() requires 1 argument"
	local arg="${1%\"}"
	local arg="${arg#\"}"
	if [[ $arg =~ ^[$__BAP_PREFIX] ]]; then
		local first=`cut -d / -f 1 <<< $arg`
		local second=`cut -d / -f 2 <<< $arg`
		local index=2
#		[[ $first = $second ]] && [[ ! $first =~ ^$__BAP_PREFIX$__BAP_PREFIX ]] && local index=1
		[[ $first = $second ]] && ! egrep -q "^([$__BAP_PREFIX])\1" <<< $first && local index=1
		local name=`tr [a-z] [A-z] <<< ${second:$index}`
		local name=`tr - _ <<< $name`
		
		local argname="__BAP_ARG_$name"
		local numname="__BAP_ARG_NUM_${name}"
		if [[ ! -z "${!numname}" ]]; then 
			echo "${!numname}"
		elif [[ -z ${!argname} ]]; then 
			echo 0
		else
			echo 1
		fi
	else 
		echo 1
	fi
}

function bap_get_int { # bap_get_int $arg
	[[ $# -lt 1 ]] && bap_error "get_int() requires at least 1 argument"
	local result=$(bap_get $1)
	[[ $result =~ ^[0-9]+$ ]] && echo $result || bap_error $1 "invalid int: '$result'"
}

function bap_get_float { # bap_get_float $arg
	[[ $# -lt 1 ]] && bap_error "get_float() requires at least 1 argument"
	local result=$(bap_get $1)
	[[ $result =~ ^[0-9]+([.][0-9]+)?$ ]] && echo $result || bap_error $1 "invalid float: '$result'"
}

function bap_get_else { # bap_get_else $arg (OR) bap_get_else $arg $default
	[[ $# -lt 1 ]] && bap_error "get_else() requires at least 1 argument"
	local result=$(bap_get $1)
	[[ -z $2 ]] && local default=false || local default=$2 
	[[ -z $result ]] && echo $default || echo $result
}

function bap_get_choice { # bap_get_choice $arg $choice1 $choice2 ...
	[[ $# -lt 2 ]] && bap_error "get_choice() requires at least two arguments"
	local arg=$1
	local result=$(bap_get $1)
	shift
	local found_choice=false
	for w in "$@"; do [ $w = $result ] && local found_choice=true; done
	
	local msg="invalid choice: '$result' (choose from $1"
	shift
	for w in "$@"; do local msg="$msg, $w"; done
	local msg="$msg)"
	
	$found_choice && echo $result || bap_error $arg "$msg"
}

function bap_add_subparsers { # bap_add_subparsers $subparser1 [$subparser2] ...
	[[ $# -lt 1 ]] && bap_error "add_subparsers() requires at least one argument"
	[[ $__BAP_NUM_POSARGS -gt 0 ]] && bap_error "scripts with subparsers cannot have positional arguments"
	local name=$(basename $0 | sed "s/\(.*\)\..*/\1/")
	for i in "$@"; do [[ ! -f $(dirname $0)/$name-$i && ! -f $(dirname $0)/$name-$i.sh ]] && bap_error "subcommand script not found: '$name-$i'"; done
	__BAP_USE_SUBPARSERS=true
	__BAP_SUBPARSER_CHOICES="$@"
	local metavar="{$1"
	shift
	for s in "$@"; do local metavar="$metavar,$s"; done
	local metavar="$metavar}"
	bap_add_posarg "subcommand" true "additional help" $metavar
}

function bap_get_subparser { # bap_get_subparser
	local name="$(dirname $0)/$(basename $0 | sed "s/\(.*\)\..*/\1/")-$__BAP_SUBPARSER"
	if [[ -f $name ]]; then echo $name
	elif [[ -f $name.sh ]]; then echo $name.sh
	fi
}

function bap_subparse { # bap_subparse "$@"
	while [[ ! $1 = $__BAP_SUBPARSER ]]; do shift; done
	shift
	$(bap_get_subparser) "$@"
}
# ===============================================================================================