local skipLevel="${1:-1}"

local pad=0

local i=

for (( i=$skipLevel; i < $(( ${#FUNCNAME[@]}-1 )); i++ )); do

local s=$(( $i+1 ))

local func="${FUNCNAME[$i]}"

local lineno="${BASH_LINENO[$i]}"

local src="${BASH_SOURCE[$s]}"

printf "%${pad}s(%s:%d) %s\n" "" "$src" "$lineno" "$func"

pad=$(( pad + 2 ))

local part="${1:0}"

local major=1

local minor=7

case "$part" in

1)

echo "$major"

;;

2)

echo "$minor"

;;

*)

echo "${major}.${minor}"

;;

return 0

local minMajor="${1:-0}"

local minMinor="${2:-0}"

local maxMajor="$3"

local maxMinor="$4"

local major="$(b_version 1)"

local minor="$(b_version 2)"

if [ $major -gt $minMajor ] ; then

#all good

:

elif [ $major -eq $minMajor ] ; then

[ $minor -ge $minMinor ] || return 1

return 2

if [ -n "$maxMajor" ] ; then

if [ $major -lt $maxMajor ] ; then

#all good

:

elif [ $major -eq $maxMajor ] ; then

[ -n "$maxMinor" ] && [ $minor -gt $maxMinor ] && return 3

else

return 4

fi

return 0

local errorOut=${1:-0}

local sendErr=${2:-0}

local sendStack=${3:-$sendErr}

local firstMsg=0

if [ $sendErr -eq 0 ] ; then

b_error "$B_ERR" $firstMsg 1

firstMsg=1

if [ $sendStack -eq 0 ] ; then

# shellcheck disable=SC2155

local stack="$(b_printStackTrace 1)"

b_error "Stack Trace:"$'\n'"$stack" $firstMsg 1

firstMsg=1

local ret=5

if [ $errorOut -eq 0 ] ; then

[ $sendErr -eq 0 ] && b_error "Aborting..." $firstMsg 1

ret=2

ret=1

[ $firstMsg -ne 0 ] && b_error "" 1 0

return $ret

local errOut=${1:-0}

local re='^([^ ]+)[ ]+[0-9]+(.*)$'

if [[ "${BLIB_STORE_VOLATILE["BLIB_ERR_HANDLER"]}" =~ $re ]] ; then

b_setErrorHandler "${BASH_REMATCH[1]} ${errOut}${BASH_REMATCH[2]}"

#special case: no arguments @error handler

b_setErrorHandler "${BLIB_STORE_VOLATILE["BLIB_ERR_HANDLER"]} $errOut"

return 0

local resetBerr="${1:-0}"

local lastInd=$(( ${#BLIB_ERR_HANDLER_LAST[@]} -1 ))

local last="b_defaultErrorHandler"

if [ $lastInd -ge 0 ] ; then

last="${BLIB_ERR_HANDLER_LAST[$lastInd]}"

unset 'BLIB_ERR_HANDLER_LAST[$lastInd]'

BLIB_STORE_VOLATILE["BLIB_ERR_HANDLER"]="$last"

[ $resetBerr -eq 0 ] && B_ERR=""

return 0

}

function b_getErrorHandler {

echo "${BLIB_STORE_VOLATILE["BLIB_ERR_HANDLER"]}"

}

function b_silence {

local ret=

local func="$1"

b_setBE 1

b_execFuncInCurrentContext "$func" "-" "$@" &> /dev/null

ret=$?

b_resetErrorHandler 1

B_E

return $ret

}

function b_readLine {

local ret="${1:-B_LINE}"

if [ $# -le 0 ] ; then

IFS= read -r "${ret?}" && return 0

IFS= read "$@" "${ret?}" && return 0

[ -n "${!ret}" ]

local pipes=("${PIPESTATUS[@]}")

local err="$1"

local i=

for ((i=0; i < ${#pipes[@]}; i++)) ; do

[ ${pipes[$i]} -ne 0 ] && B_ERR="${err:-"One of the previous pipe operations failed (index: $i)."}" && B_E

return 0

local mtype="$1"

local msg="$2"

local first="${3:-0}"

local last="${4:-0}"

local prefix=""

local suffix=""

if [ $first -eq 0 ] ; then

if [ -n "$msg" ] ; then

prefix="${BLIB_DEFAULT_MSG_HANDLER_PREFIXES["$mtype"]}"

fi

prefix="${BLIB_STORE["BLIB_DEFAULT_MSG_HANDLER_INTERMEDIATE"]}"

if [ $last -eq 0 ] ; then

suffix=$'\n'

[ -z "$msg" ] && prefix="" #special case: no message, just finalize any previous message parts

if [ $mtype -eq 0 ] ; then

printf '%s%s%s' "$prefix" "$msg" "$suffix"

printf '%s%s%s' "$prefix" "$msg" "$suffix" >&2

return 0

local mhandler="$1"

local mtype="$2"

local msg="$3"

local first="${4:-0}"

local last="${5:-0}"

local cfile="${BLIB_CACHING_MSG_HANDLER_CACHES["$mtype"]}"

if [ -z "$cfile" ] ; then

b_defaultMessageHandler 1 "Implementation error: b_cachingMessageHandler $mhandler was called without calling b_initCachingMessageHandler at least once. Dropping the following message:"$'\n'"$msg"

return 0

if [ $last -eq 0 ] ; then

if [ $first -eq 0 ] ; then

#no need for caching

"$mhandler" "$mtype" "$msg" "$@"

else

#read & clear cache (atomically)

#NOTE: we want to perform this operation _atomically_ in order to not lose messages coming from threads running concurrently --> we use mv as it uses the rename syscall which is atomic on most unix systems

local cfileTmp=

cfileTmp="$(mktemp -u)" || { b_defaultMessageHandler 1 "Failed to call mktemp -u." ; return 0 ; }

mv -f "$cfile" "$cfileTmp" &> /dev/null || { b_defaultMessageHandler 1 "Failed to move $cfile to $cfileTmp." ; return 0 ; }

local cmsg=

cmsg="$(<"$cfileTmp")" || { b_defaultMessageHandler 1 "Failed to read $cfileTmp." ; return 0 ; }

rm -f "$cfileTmp" &> /dev/null || { b_defaultMessageHandler 1 "Failed to remove $cfileTmp." ; return 0 ; }

#generate the final message

local inter=""

[ -n "$msg" ] && inter="${BLIB_STORE["BLIB_DEFAULT_MSG_HANDLER_INTERMEDIATE"]}"

printf -v msg "%s%s%s" "$cmsg" "$inter" "$msg"

#pass the final message to the chained handler

"$mhandler" "$mtype" "$msg" "$@"

fi

#first is 0 or 1 and last is 1 --> write to cache (non-atomically)

if [ $first -eq 0 ] ; then

echo -n "$msg" > "$cfile" || { b_defaultMessageHandler 1 "Failed to write to the cache file $cfile." ; return 0 ; }

else

echo -n "${BLIB_STORE["BLIB_DEFAULT_MSG_HANDLER_INTERMEDIATE"]}$msg" >> "$cfile" || { b_defaultMessageHandler 1 "Failed to write to the cache file $cfile." ; return 0 ; }

fi

return 0

local max="${1:-1}"

b_import "traps" || B_E

local i=

local cfile=

local cmd=

for ((i=0; i <= max; i++)) ; do

#use a temporary file as cache

#NOTE: this is the closest we can get to stdout/stderr as it is inherited/shared to subthreads similarly to stdout/stderr

cfile="$(mktemp)" || { B_ERR="Failed to allocate a temporary file." ; B_E ; }

BLIB_CACHING_MSG_HANDLER_CACHES["$i"]="$cfile"

if [ $B_TEST_MODE -ne 0 ] ; then

#schedule cleanup

#NOTE: bats uses the EXIT signal itself, so that we cannot do this during testing

printf -v cmd 'rm -f %q &> /dev/null' "$cfile"

b_traps_add "$cmd" "EXIT" || B_E

fi

local user="$1"

[ "$(whoami)" != "$user" ] && B_ERR="This script must be run as ${user}." && B_E

return 0

local path="$1"

local prefix="${2:-$path}"

[[ "$prefix" != *"/" ]] && prefix="${prefix}/"

local ret=""

for file in "$path"/* ; do

local fname="${file#"$prefix"}"

if [ -f "$file" ] ; then

[ -n "$ret" ] && ret="$ret"$'\n'

ret="$ret$fname"

elif [ -d "$file" ] ; then

[ -n "$ret" ] && ret="$ret"$'\n'

ret="$ret$( blib_getBlibModules "$file" "$prefix" )"

else

continue

fi

echo "$ret"

if [ -z "${BLIB_STORE_VOLATILE["BLIB_MODULE_LIST_CACHE"]}" ] ; then

local ret="${BLIB_STORE["BLIB_SCRIPT_NAME"]}"

ret="$ret"$'\n'"$(blib_getBlibModules "${BLIB_STORE["BLIB_LIB_DIR"]}")"

BLIB_STORE_VOLATILE["BLIB_MODULE_LIST_CACHE"]="$(echo "$ret" | sort)"

echo "${BLIB_STORE_VOLATILE["BLIB_MODULE_LIST_CACHE"]}"

local module="$1"

local retDir=""

if [[ "$module" == "${BLIB_STORE["BLIB_SCRIPT_NAME"]}" ]] ; then

retDir="${BLIB_STORE["BLIB_SCRIPT_DIR"]}"

retDir="${BLIB_STORE["BLIB_LIB_DIR"]}"

local ret="$retDir/$module"

[ ! -f "$ret" ] && B_ERR="The module $module cannot be found at $ret or is inaccessible." && B_E

echo "$ret"

local list="$1"

local entry="$2"

while b_readLine ; do

[[ "$B_LINE" == "$entry" ]] && return 0

done <<< "$list"

return 1

local dep=

local unmet=""

for dep in "$@" ; do

[ -z "$dep" ] && continue

command -v "$dep" &> /dev/null || unmet="$dep"$'\n'"$unmet"

[ -z "$unmet" ] || { B_ERR="The script requires the following commands, but they were not found:"$'\n'"$unmet" ; B_E ; }

local module="$1"

local doubleImport="${2:-0}"

local modulePath=""

[ $doubleImport -ne 1 ] && b_listContains "${BLIB_STORE["BLIB_IMPORTED_MODULES"]}" "$module" && return 0

[[ "$module" == "${BLIB_STORE["BLIB_SCRIPT_NAME"]}" ]] && B_ERR="Cannot import $module itself." && B_E

if [ "${BLIB_STORE["BLIB_STANDALONE_MODE"]}" -ne 0 ] ; then

modulePath="$(blib_getModulePath "$module")" || { B_ERR="Failed to obtain the path for the module $module."; B_E; }

source "$modulePath" || { B_ERR="Failed to import the module $module from ${modulePath}."; B_E; }

BLIB_STORE["BLIB_IMPORTED_MODULES"]="${BLIB_STORE["BLIB_IMPORTED_MODULES"]}"$'\n'"$module"

return 0

echo "Usage: blib [command] [command parameters]

exit 1

local func="$1"

local dep=""

local mod=""

local modulePath=""

local par=""

declare -a mdeps=()

for par in "$@" ; do

[[ "$par" == "-" ]] && shift && break

mdeps+=("$par")

shift

declare -a fdeps=()

for par in "$@" ; do

[[ "$par" == "-" ]] && shift && break

fdeps+=("$par")

shift

local funcCall="$func"

for par in "$@" ; do

[[ "$par" == "-" ]] && shift && break

printf -v par '%q' "$par"

funcCall="$funcCall $par"

shift

local mainCnt=0

local inMain=1

local main=""

local line=

while b_readLine line ; do

if [ $inMain -eq 0 ] ; then

if [[ "$line" == "#BLIB_MAIN_END" ]] ; then

main="$main"$'\n'"$line"

inMain=1

elif [[ "$line" == *'"$@"' ]] ; then

main="$main"$'\n'" $funcCall"' "$@"'

else

main="$main"$'\n'"$line"

fi

elif [[ "$line" == "#BLIB_MAIN_BEGIN" ]] ; then

main="$main"$'\n'"$line"

inMain=0

mainCnt=$(( $mainCnt +1 ))

else

echo "$line"

fi

done < "${BASH_SOURCE[0]}"

[ $mainCnt -ne 1 ] && B_ERR="Failed to find the blib_main call." && B_E

[ $inMain -ne 1 ] && B_ERR="Failed to find the MAIN_END marker." && B_E

echo ""

echo 'BLIB_STORE["BLIB_STANDALONE_MODE"]="0"'

for mod in "${mdeps[@]}" ; do

if [ ${BLIB_STORE["BLIB_STANDALONE_MODE"]} -ne 0 ] ; then

#we only add module content in normal mode (in standalone they either were added before or won't be found)

modulePath="$(blib_getModulePath "$mod")" || { B_ERR="Failed to obtain the path for the module $mod."; B_E; }

echo ""

cat "$modulePath" || { B_ERR="Failed to read $modulePath."; B_E; }

fi

for dep in "${fdeps[@]}" ; do

echo ""

declare -f "$dep" || { B_ERR="Failed to find the declaration for the function $dep."; B_E; }

echo ""

declare -f "$func" || { B_ERR="Failed to find the declaration for the function $func."; B_E; }

echo ""

echo "$main"

return 0

local func="$1"

local par=""

local mod=""

for mod in "$@" ; do

[[ "$mod" == "-" ]] && shift && break

b_import "$mod" || B_E

shift

local funcCall="$func"

for par in "$@" ; do

printf -v par '%q' "$par"

funcCall="$funcCall $par"

shift

eval "$funcCall"