skylab/MasterPassword
2
0
Fork 0
Code Releases Activity
073ef4f439
MasterPassword/platform-independent/scripts/bashlib

1699 lines
57 KiB
Plaintext
Raw Normal View History

Added bashlib.
2017-09-14 20:44:32 +00:00
#! /usr/bin/env bash
# ___________________________________________________________________________ #
# #
# BashLIB -- A library for Bash scripting convenience. #
# #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); #
# you may not use this file except in compliance with the License. #
# You may obtain a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
# ___________________________________________________________________________ #
# #
# #
# Copyright 2007-2013, lhunath #
# * http://www.lhunath.com #
# * Maarten Billemont #
# #
# ______________________________________________________________________
# | |
# | .: TABLE OF CONTENTS :. |
# |______________________________________________________________________|
#
# chr decimal
# Outputs the character that has the given decimal ASCII value.
#
# ord character
# Outputs the decimal ASCII value of the given character.
#
# hex character
# Outputs the hexadecimal ASCII value of the given character.
#
# unhex character
# Outputs the character that has the given decimal ASCII value.
#
# max numbers...
# Outputs the highest of the given numbers.
#
# min numbers...
# Outputs the lowest of the given numbers.
#
# totime "YYYY-MM-DD HH:MM:SS.mmm"...
# Outputs the number of milliseconds in the given date string(s).
#
# exists application
# Succeeds if the application is in PATH and is executable.
#
# eol message
# Return termination punctuation for a message, if necessary.
#
# hr pattern [length]
# Outputs a horizontal ruler of the given length in characters or the terminal column length otherwise.
#
# cloc
# Outputs the current cursor location as two space-separated numbers: row column.
#
# readwhile command [args]
# Outputs the characters typed by the user into the terminal's input buffer while running the given command.
#
# log [format] [arguments...]
# Log an event at a certain importance level.
# The event is expressed as a printf(1) format argument.
#
# ask [-c optionchars|-d default] [-s|-S maskchar] message...
# Ask a question and read the user's reply to it. Then output the result on stdout.
#
# trim lines ...
# Trim the whitespace off of the beginning and end of the given lines.
#
# reverse [-0|-d delimitor] [elements ...] [<<< elements]
# Reverse the order of the given elements.
#
# order [-0|-d char] [-[cC] comparator|-n] [-t number] [elements ...] [<<< elements]
# Orders the elements in ascending order.
#
# mutex file
# Open a mutual exclusion lock on the file, unless another process already owns one.
#
# pushjob [poolsize] command
# Start an asynchronous command within a pool, waiting for space in the pool if it is full.
#
# fsleep time
# Wait for the given (fractional) amount of seconds.
#
# showHelp name description author [option description]...
# Generate a prettily formatted usage description of the application.
#
# shquote [-e] [argument...]
# Shell-quote the arguments to make them safe for injection into bash code.
#
# requote [string]
# Escape the argument string to make it safe for injection into a regex.
#
# shorten [-p pwd] path [suffix]...
# Shorten an absolute path for pretty printing.
#
# up .../path|num
# Walk the current working directory up towards root num times or until path is found.
#
# buildarray name terms... -- elements...
# Create an array by adding all the terms to it for each element, replacing {} terms by the element.
#
# inArray element array
# Checks whether a certain element is in the given array.
#
# xpathNodes query [files...]
# Outputs every xpath node that matches the query on a separate line.
#
# hideDebug [on|off]
# Toggle Bash's debugging mode off temporarily.
#
# stackTrace
# Output the current script's function execution stack.
#
_tocHash=71e13f42e1ea82c1c7019b27a3bc71f3
# ______________________________________________________________________
# | |
# | .: GLOBAL CONFIGURATION :. |
# |______________________________________________________________________|
# Unset all exported functions. Exported functions are evil.
while read _ _ func; do
command unset -f "$func"
done < <(command declare -Fx)
{
shopt -s extglob
shopt -s globstar
} 2>/dev/null ||:
# Generate Table Of Contents
genToc() {
local line= comments=() usage= whatis= lineno=0 out= outhash= outline=
while read -r line; do
(( ++lineno ))
[[ $line = '#'* ]] && comments+=("$line") && continue
[[ $line = +([[:alnum:]])'() {' ]] && IFS='()' read func _ <<< "$line" && [[ $func != $FUNCNAME ]] && {
usage=${comments[3]##'#'+( )}
whatis=${comments[5]##'#'+( )}
[[ $usage = $func* && $whatis = *. ]] || err "Malformed docs for %s (line %d)." "$func" "$lineno"
printf -v outline '# %s\n# %s\n#\n' "$usage" "$whatis"
out+=$outline
}
comments=()
done < ~/.bin/bashlib
outhash=$(openssl md5 <<< "$out")
if [[ $_tocHash = "$outhash" ]]; then
inf 'Table of contents up-to-date.'
else
printf '%s' "$out"
printf '_tocHash=%q' "$outhash"
wrn 'Table of contents outdated.'
fi
}
# ______________________________________________________________________
# | |
# | .: GLOBAL DECLARATIONS :. |
# |______________________________________________________________________|
# Environment
TMPDIR=${TMPDIR:-/tmp} TMPDIR=${TMPDIR%/}
# Variables for convenience sequences.
bobber=( '.' 'o' 'O' 'o' )
spinner=( '-' \\ '|' '/' )
crosser=( '+' 'x' '+' 'x' )
runner=( '> >' \
'>> ' \
' >>' )
# Variables for terminal requests.
[[ -t 2 && $TERM != dumb ]] && {
COLUMNS=$({ tput cols || tput co;} 2>&3) # Columns in a line
LINES=$({ tput lines || tput li;} 2>&3) # Lines on screen
alt=$( tput smcup || tput ti ) # Start alt display
ealt=$( tput rmcup || tput te ) # End alt display
hide=$( tput civis || tput vi ) # Hide cursor
show=$( tput cnorm || tput ve ) # Show cursor
save=$( tput sc ) # Save cursor
load=$( tput rc ) # Load cursor
dim=$( tput dim || tput mh ) # Start dim
bold=$( tput bold || tput md ) # Start bold
stout=$( tput smso || tput so ) # Start stand-out
estout=$( tput rmso || tput se ) # End stand-out
under=$( tput smul || tput us ) # Start underline
eunder=$( tput rmul || tput ue ) # End underline
reset=$( tput sgr0 || tput me ) # Reset cursor
blink=$( tput blink || tput mb ) # Start blinking
italic=$( tput sitm || tput ZH ) # Start italic
eitalic=$( tput ritm || tput ZR ) # End italic
[[ $TERM != *-m ]] && {
red=$( tput setaf 1|| tput AF 1 )
green=$( tput setaf 2|| tput AF 2 )
yellow=$( tput setaf 3|| tput AF 3 )
blue=$( tput setaf 4|| tput AF 4 )
magenta=$( tput setaf 5|| tput AF 5 )
cyan=$( tput setaf 6|| tput AF 6 )
}
black=$( tput setaf 0|| tput AF 0 )
white=$( tput setaf 7|| tput AF 7 )
default=$( tput op )
eed=$( tput ed || tput cd ) # Erase to end of display
eel=$( tput el || tput ce ) # Erase to end of line
ebl=$( tput el1 || tput cb ) # Erase to beginning of line
ewl=$eel$ebl # Erase whole line
draw=$( tput -S <<< ' enacs
smacs
acsc
rmacs' || { \
tput eA; tput as;
tput ac; tput ae; } ) # Drawing characters
back=$'\b'
} 3>&2 2>/dev/null ||:
# ______________________________________________________________________
# | |
# | .: FUNCTION DECLARATIONS :. |
# |______________________________________________________________________|
# ______________________________________________________________________
# |__ Chr _______________________________________________________________|
#
# chr decimal
#
# Outputs the character that has the given decimal ASCII value.
#
chr() {
printf "\\$(printf '%03o' "$1")"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Ord _______________________________________________________________|
#
# ord character
#
# Outputs the decimal ASCII value of the given character.
#
ord() {
Make mpw_mkpw symlinkable.
2017-10-06 17:33:08 +00:00
local str=$1 s
for (( s=0; s < ${#str}; ++s )); do
printf '%d' "'${str:s:1}"
done
Added bashlib.
2017-09-14 20:44:32 +00:00
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Hex _______________________________________________________________|
#
# hex character
#
# Outputs the hexadecimal ASCII value of the given character.
#
hex() {
Make mpw_mkpw symlinkable.
2017-10-06 17:33:08 +00:00
local str=$1 s
for (( s=0; s < ${#str}; ++s )); do
printf '%02X' "'${str:s:1}"
done
Added bashlib.
2017-09-14 20:44:32 +00:00
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Unhex _______________________________________________________________|
#
# unhex character
#
# Outputs the character that has the given hexadecimal ASCII value.
#
unhex() {
Make mpw_mkpw symlinkable.
2017-10-06 17:33:08 +00:00
local hex=$1 h
for (( h=0; h < ${#hex}; h+=2 )); do
printf "\\x${hex:h:2}"
done
Added bashlib.
2017-09-14 20:44:32 +00:00
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ max _______________________________________________________________|
#
# max numbers...
#
# Outputs the highest of the given numbers.
#
max() {
local max=$1 n
for n; do
(( n > max )) && max=$n
done
printf %d "$max"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ min _______________________________________________________________|
#
# min numbers...
#
# Outputs the lowest of the given numbers.
#
min() {
local min=$1 n
for n; do
(( n < min )) && min=$n
done
printf '%d' "$min"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ si ________________________________________________________________|
#
# si number
#
# Output a human-readable version of the number using SI units.
#
si() {
local number=$1
if (( number >= 1000000000000000 )); then printf '%dM' "$((number / 1000000000000000))"
elif (( number >= 1000000000000 )); then printf '%dM' "$((number / 1000000000000))"
elif (( number >= 1000000000 )); then printf '%dM' "$((number / 1000000000))"
elif (( number >= 1000000 )); then printf '%dM' "$((number / 1000000))"
elif (( number >= 1000 )); then printf '%dk' "$((number / 1000))"
else printf '%d' "$number"; fi
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ totime ____________________________________________________________|
#
# totime "YYYY-MM-DD HH:MM:SS.mmm"...
#
# Outputs the number of milliseconds in the given date string(s).
#
# When multiple date string arguments are given, multiple time strings are output, one per line.
#
# The fields should be in the above defined order. The delimitor between the fields may be any one of [ -:.].
# If a date string does not follow the defined format, the result is undefined.
#
# Note that this function uses a very simplistic conversion formula which does not take any special calendar
# convenions into account. It assumes there are 12 months in evert year, 31 days in every month, 24 hours
# in every day, 60 minutes in every hour, 60 seconds in every minute and 1000 milliseconds in every second.
#
totime() {
local arg time year month day hour minute second milli
for arg; do
IFS=' -:.' read year month day hour minute second milli <<< "$arg" &&
(( time = (((((((((((10#$year * 12) + 10#$month) * 31) + 10#$day) * 24) + 10#$hour) * 60) + 10#$minute) * 60) + 10#$second) * 1000) + 10#$milli )) &&
printf '%d\n' "$time"
done
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Exists ____________________________________________________________|
#
# exists application
#
# Succeeds if the application is in PATH and is executable.
#
exists() {
[[ -x $(type -P "$1" 2>/dev/null) ]]
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ FirstExists ____________________________________________________________|
#
# firstExists file...
#
# Outputs the first of the arguments that is a file which exists.
#
firstExists() {
local file;
for file; do
[[ -e "$file" ]] && printf %s "$file" && exit
done
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Eol _______________________________________________________________|
#
# eol message
#
# Return termination punctuation for a message, if necessary.
#
eol() {
: #[[ $1 && $1 != *[\!\?.,:\;\|] ]] && printf .. ||:
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Hr _______________________________________________________________|
#
# hr pattern [length]
#
# Outputs a horizontal ruler of the given length in characters or the terminal column length otherwise.
# The ruler is a repetition of the given pattern string.
#
hr() {
local pattern=${1:--} length=${2:-$COLUMNS} ruler=
while (( ${#ruler} < length )); do
ruler+=${pattern:0:length-${#ruler}}
done
printf %s "$ruler"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ CLoc ______________________________________________________________|
#
# cloc
#
# Outputs the current cursor location as two space-separated numbers: row column.
#
cloc() {
local old=$(stty -g)
trap 'stty "$old"' RETURN
stty raw
# If the tty has input waiting then we can't read back its response. We'd only break and pollute the tty input buffer.
read -t 0 < /dev/tty 2>/dev/null && return 1
printf '\e[6n' > /dev/tty
IFS='[;' read -dR _ row col < /dev/tty
printf '%d %d' "$row" "$col"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ readwhile ______________________________________________________________|
#
# readwhile command [args]
#
# Outputs the characters typed by the user into the terminal's input buffer while running the given command.
#
readwhile() {
local old=$(stty -g) in result REPLY
trap 'stty "$old"' RETURN
stty raw
"$@"
result=$?
while read -t 0; do
IFS= read -rd '' -n1 && in+=$REPLY
done
printf %s "$in"
return $result
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Latest ____________________________________________________________|
#
# latest [file...]
#
# Output the argument that represents the file with the latest modification time.
#
latest() (
shopt -s nullglob
local file latest=$1
for file; do
[[ $file -nt $latest ]] && latest=$file
done
printf '%s\n' "$latest"
) # _____________________________________________________________________
# _______________________________________________________________________
# |__ Iterate ____________________________________________________________|
#
# iterate [command]
#
# All arguments to iterate make up a single command that will be executed.
#
# Any of the arguments may be of the format {x..y[..z]} which causes the command
# to be executed in a loop, each iteration substituting the argument for the
# current step the loop has reached from x to y. We step from x to y by
# walking from x's position in the ASCII character table to y's with a step of z
# or 1 if z is not specified.
#
iterate() (
local command=( "$@" ) iterationCommand=() loop= a= arg= current=() step=() target=()
for a in "${!command[@]}"; do
arg=${command[a]}
if [[ $arg = '{'*'}' ]]; then
loop=${arg#'{'} loop=${loop%'}'}
step[a]=${loop#*..*..} current[a]=${loop%%..*} target[a]=${loop#*..} target[a]=${target[a]%.."${step[a]}"}
[[ ! ${step[a]} || ${step[a]} = $loop ]] && step[a]=1
fi
done
if (( ${#current[@]} )); then
for loop in "${!current[@]}"; do
while true; do
iterationCommand=()
for a in "${!command[@]}"; do
(( a == loop )) \
&& iterationCommand+=( "${current[a]}" ) \
|| iterationCommand+=( "${command[a]}" )
done
iterate "${iterationCommand[@]}"
[[ ${current[loop]} = ${target[loop]} ]] && break
current[loop]="$(chr "$(( $(ord "${current[loop]}") + ${step[loop]} ))")"
done
done
else
"${command[@]}"
fi
) # _____________________________________________________________________
# _______________________________________________________________________
# |__ csvline ____________________________________________________________|
#
# csvline [-d delimiter] [-D line-delimiter]
#
# Parse a CSV record from standard input, storing the fields in the CSVLINE array.
#
# By default, a single line of input is read and parsed into comma-delimited fields.
# Fields can optionally contain double-quoted data, including field delimiters.
#
# A different field delimiter can be specified using -d. You can use -D
# to change the definition of a "record" (eg. to support NULL-delimited records).
#
csvline() {
CSVLINE=()
local line field quoted=0 delimiter=, lineDelimiter=$'\n' c
local OPTIND=1 arg
while getopts :d: arg; do
case $arg in
d) delimiter=$OPTARG ;;
esac
done
IFS= read -d "$lineDelimiter" -r line || return
while IFS= read -rn1 c; do
case $c in
\")
(( quoted = !quoted ))
continue ;;
$delimiter)
if (( ! quoted )); then
CSVLINE+=( "$field" ) field=
continue
fi ;;
esac
field+=$c
done <<< "$line"
[[ $field ]] && CSVLINE+=( "$field" ) ||:
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Logging ___________________________________________________________|
#
# log format [arguments...]
#
# Log an event at a certain importance level. The event is expressed as a printf(1) format argument.
# The current exit code remains unaffected by the execution of this function.
#
# Instead of 'log', you can use a level as command name, to log at that level. Using log, messages are
# logged at level inf. The supported levels are: trc, dbg, inf, wrn, err, ftl.
#
# If you prefix the command name with a p, the log message is shown as a spinner and waits for the next
# closing statement. Eg.
#
# pinf 'Converting image'
# convert image.png image.jpg
# fnip
#
# The closing statement (here fnip) is the reverse of the opening statement and exits with the exit code
# of the last command. If the last command failed, it shows the exit code in the spinner before it is stopped.
# The closing statement also takes a format and arguments, which are displayed in the spinner.
#
log() {
local exitcode=$? result=0 level=${level:-inf} supported=0 end=$'\n' type=msg conMsg= logMsg= format= colorFormat= date= info= arg= args=() colorArgs=() ruler=
# Handle options.
local OPTIND=1
while getopts :tpuPrR:d:nx arg; do
case $arg in
p)
end='.. '
type=startProgress ;;
u)
end='.. '
type=updateProgress ;;
P)
type=stopProgress ;;
r)
ruler='____' ;;
R)
ruler=$OPTARG ;;
d)
end=$OPTARG ;;
n)
end= ;;
x)
result=$exitcode ;;
esac
done
shift "$((OPTIND-1))"
format=$1 args=( "${@:2}" )
(( ! ${#args[@]} )) && [[ $format ]] && { args=("$format") format=%s; local bold=; }
date=${_logDate+$(date +"${_logDate:-%H:%M}")}
# Level-specific settings.
local logLevelColor
case $level in
TRC) (( supported = _logVerbosity >= 4 ))
logLevelColor=$_logTrcColor ;;
DBG) (( supported = _logVerbosity >= 3 ))
logLevelColor=$_logDbgColor ;;
INF) (( supported = _logVerbosity >= 2 ))
logLevelColor=$_logInfColor ;;
WRN) (( supported = _logVerbosity >= 1 ))
logLevelColor=$_logWrnColor ;;
ERR) (( supported = _logVerbosity >= 0 ))
logLevelColor=$_logErrColor ;;
FTL) (( supported = 1 ))
logLevelColor=$_logFtlColor ;;
*)
log FTL 'Log level %s does not exist' "$level"
exit 1 ;;
esac
(( ! supported )) && return "$result"
local logColor=${_logColor:+$logLevelColor}
# Generate the log message.
case $type in
msg|startProgress)
printf -v logMsg "${date:+%s }${_logLevel:+%-3s }$format$end" ${date:+"$date"} ${_logLevel:+"$level"} "${args[@]}"
if (( _logColor )); then
colorFormat=$(sed ${reset:+-e "s/$(requote "$reset")/$reset$_logAttributes$logColor/g"} -e "s/%[^a-z]*[a-z]/$reset$_logAttributes$bold$logColor&$reset$_logAttributes$logColor/g" <<< "$format")
colorArgs=("${args[@]//$reset/$reset$_logAttributes$bold$logColor}")
printf -v conMsg "$reset$_logAttributes${date:+%s }${_logLevel:+$logColor$bold%-3s$reset $_logAttributes}$logColor$colorFormat$reset$_logAttributes$black\$$reset$end$save" ${date:+"$date"} ${_logLevel:+"$level"} "${colorArgs[@]}"
else
conMsg=$logMsg
fi
;;
updateProgress)
printf -v logMsg printf " [$format]" "${args[@]}"
if (( _logColor )); then
colorFormat=$(sed ${reset:+-e "s/$(requote "$reset")/$reset$_logAttributes$logColor/g"} -e "s/%[^a-z]*[a-z]/$reset$_logAttributes$bold$logColor&$reset$_logAttributes$logColor/g" <<< "$format")
colorArgs=("${args[@]//$reset/$reset$_logAttributes$bold$logColor}")
printf -v conMsg "$load$eel$blue$bold[$reset$_logAttributes$logColor$colorFormat$reset$_logAttributes$blue$bold]$reset$end" "${colorArgs[@]}"
else
conMsg=$logMsg
fi
;;
stopProgress)
kill -0 "$_logSpinner" 2>/dev/null || return
case $exitcode in
0) printf -v logMsg "done${format:+ ($format)}.\n" "${args[@]}"
if (( _logColor )); then
colorFormat=$(sed ${reset:+-e "s/$(requote "$reset")/$reset$logColor/g"} -e "s/%[^a-z]*[a-z]/$reset$bold$logColor&$reset$logColor/g" <<< "$format")
colorArgs=("${args[@]//$reset/$reset$bold$logColor}")
printf -v conMsg "$load$eel$green${bold}done${colorFormat:+ ($reset$logColor$colorFormat$reset$green$bold)}$reset.\n" "${colorArgs[@]}"
else
conMsg=$logMsg
fi
;;
*) info=${format:+$(printf ": $format" "${args[@]}")}
printf -v logMsg "error(%d%s).\n" "$exitcode" "$info"
if (( _logColor )); then
printf -v conMsg "${eel}${red}error${reset}(${bold}${red}%d${reset}%s).\n" "$exitcode" "$info"
else
conMsg=$logMsg
fi
;;
esac
;;
esac
# Create the log file.
if [[ $_logFile && ! -e $_logFile ]]; then
[[ $_logFile = */* ]] || _logFile=./$_logFile
mkdir -p "${_logFile%/*}" && touch "$_logFile"
fi
# Stop the spinner.
if [[ $type = stopProgress && $_logSpinner ]]; then
{
kill "$_logSpinner" ||:
wait "$_logSpinner" ||:
unset _logSpinner
} 2>/dev/null
fi
# Output the ruler.
if [[ $ruler ]]; then
printf >&2 '%s\n' "$(hr "$ruler")"
[[ -w $_logFile ]] \
&& printf >> "$_logFile" '%s' "$ruler"
fi
# Output the log message.
printf >&2 '%s' "$conMsg"
[[ -w $_logFile ]] \
&& printf >> "$_logFile" '%s' "$logMsg"
# Start the spinner.
if [[ $type = startProgress && ! $_logSpinner && $TERM != dumb ]]; then
{
set +m
trap 'printf >&2 %s "$show"' EXIT
printf >&2 %s "$hide"
while printf >&2 "$eel$blue$bold[$reset%s$reset$blue$bold]$reset\b\b\b" "${spinner[s++ % ${#spinner[@]}]}" && sleep .1
do :; done
} & _logSpinner=$!
addtrap EXIT 'level=%q _logSpinner=%q golp' "$level" "$_logSpinner"
fi
return $result
}
trc() { level=TRC log "$@"; }
dbg() { level=DBG log "$@"; }
inf() { level=INF log "$@"; }
wrn() { level=WRN log "$@"; }
err() { level=ERR log "$@"; }
ftl() { level=FTL log "$@"; }
plog() { log -p "$@"; }
ulog() { log -u "$@"; }
golp() { log -P "$@"; }
ptrc() { level=TRC plog "$@"; }
pdbg() { level=DBG plog "$@"; }
pinf() { level=INF plog "$@"; }
pwrn() { level=WRN plog "$@"; }
perr() { level=ERR plog "$@"; }
pftl() { level=FTL plog "$@"; }
utrc() { level=TRC ulog "$@"; }
udbg() { level=DBG ulog "$@"; }
uinf() { level=INF ulog "$@"; }
uwrn() { level=WRN ulog "$@"; }
uerr() { level=ERR ulog "$@"; }
uftl() { level=FTL ulog "$@"; }
gtrc() { level=trc golp "$@"; }
gbdp() { level=DBG golp "$@"; }
fnip() { level=INF golp "$@"; }
nrwp() { level=WRN golp "$@"; }
rrep() { level=ERR golp "$@"; }
ltfp() { level=FTL golp "$@"; }
_logColor=${_logColor:-$([[ -t 2 ]] && echo 1)} _logVerbosity=2
_logTrcColor=$grey _logDbgColor=$blue _logInfColor=$white _logWrnColor=$yellow _logErrColor=$red _logFtlColor=$bold$red
#_logDate=%H:%M # Set this to enable date output in log messages.
#_logLevel=1 # Set this to enable level output in log messages.
# _______________________________________________________________________
# ______________________________________________________________________
# |__ Ask _______________________________________________________________|
#
# ask [-c optionchars|-d default] [-s|-S maskchar] format [arguments...]
#
# Ask a question and read the user's reply to it. Then output the result on stdout.
#
# When in normal mode, a single line is read. If the line is empty and
# -d was specified, the default argument is output instead of an empty line.
# The exit code is always 0.
#
# When in option mode (-c), the user is shown the option characters with
# which he can reply and a single character is read.
# If the reply is empty (user hits enter) and any of the optionchars are
# upper-case, the upper-case option (= the default option) character will
# be output instead of an empty line.
# If the reply character is not amoungst the provided options the default
# option is again output instead if present. If no default was given, an
# exit code of 2 is returned.
# You may mark an optionchar as 'valid' by appending a '!' to it. As a
# result, an exit code of 0 will only be returned if this valid option
# is replied. If not, an exit code of 1 will be returned.
#
ask() {
# Initialize the vars.
local opt arg
local option=
local options=
local default=
local silent=
local valid=
local muteChar=
local format=
# Parse the options.
local OPTIND=1
while getopts :sS:c:d: opt; do
case $opt in
s) silent=1 ;;
S) silent=1 muteChar=$OPTARG ;;
c) while read -n1 arg; do
case $arg in
[[:upper:]]) default=$arg ;;
!) valid=${options: -1}; continue ;;
esac
options+=$arg
done <<< "$OPTARG" ;;
d) default=$OPTARG option=$default ;;
esac
done
# Trim off the options.
shift $((OPTIND-1))
# Figure out what FD to use for our messages.
[[ -t 1 ]] && local fd=1 || local fd=2
# Ask the question.
format=$1; shift
level=${level:-WRN} log -n "$format${option:+ [%s]}${options:+ [%s]}" "$@" ${option:+"$option"} ${options:+"$options"}
# Read the reply.
exec 8<&0; [[ -t 8 ]] || exec 8</dev/tty
if [[ $muteChar ]]; then
local reply
while read -u8 -s -n1 && [[ $REPLY ]]; do
reply+=$REPLY
printf '%s' "$muteChar" >&$fd
done
REPLY=$reply
[[ $options && $REPLY ]] || (( silent )) && printf '\n' >&$fd
else
read -u8 -e ${options:+-n1} ${silent:+-s}
fi
# Evaluate the reply.
while true; do
if [[ $REPLY && ( ! $options || $options = *$REPLY* ) ]]; then
if [[ $valid ]]
then [[ $REPLY = $valid ]]
else printf "%s" "$REPLY"
fi
return
fi
[[ -z $default || $REPLY = $default ]] \
&& return 2
REPLY=$default
done
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Trim ______________________________________________________________|
#
# trim lines ...
#
# Trim the whitespace off of the beginning and end of the given lines.
# Each argument is considdered one line; is treated and printed out.
#
# When no arguments are given, lines will be read from standard input.
#
trim() {
{ (( $# )) && printf '%s\n' "$@" || cat; } | \
sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//'
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Reverse ___________________________________________________________|
#
# reverse [-0|-d delimitor] [elements ...] [<<< elements]
#
# Reverse the order of the given elements.
# Elements are read from command arguments or standard input if no element
# arguments are given.
# They are reversed and output on standard output.
#
# If the -0 option is given, input and output are delimited by NUL bytes.
# If the -d option is given, input and output are delimited by the
# character argument.
# Otherwise, they are delimited by newlines.
#
reverse() {
# Initialize the vars.
local elements=() delimitor=$'\n' i
# Parse the options.
local OPTIND=1
while getopts :0d: opt; do
case $opt in
0) delimitor=$'\0' ;;
d) delimitor=$OPTARG ;;
esac
done
shift "$((OPTIND-1))"
# Get the elements.
if (( $# )); then
elements=( "$@" )
else
while IFS= read -r -d "$delimitor"; do
elements+=("$REPLY")
done
fi
# Iterate in reverse order.
for (( i=${#elements[@]} - 1; i >=0; --i )); do
printf "%s${delimitor:-'\0'}" "${elements[i]}"
done
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Order _____________________________________________________________|
#
# order [-0|-d char] [-[fF] isDesired] [-[cC] comparator|-n|-R|-t] [-r] [-T number] [-a array|elements ...] [<<< elements]
#
# Orders the elements in ascending order.
# Elements are read from command arguments or standard input if no element
# arguments are given.
# The result is output on standard output.
#
# By default, the elements will be ordered using lexicographic comparison.
# If the -n option is given, the elements will be ordered numerically.
# If the -R option is given, the elements will be ordered randomly.
# If the -t option is given, the elements are ordered by file mtime.
# If the -f option is given, the command name following it will be used
# as a filter.
# If the -c option is given, the command name following it will be used
# as a comparator.
# If the -C option is given, the bash code following it will be used
# as a comparator.
# If the -r option is given, the ordering will be reversed.
# If the -T option is given, only the first number results are returned.
# If the -a option is given, the elements in array are ordered instead and
# array is mutated to contain the result.
# If number is 0, all results are returned.
#
# isDesired is a command name which will get one parameter. The parameter
# is an element which will only be included if the command exits successfully.
# comparator is a command name which will be executed for each element
# comparison and will be passed two element arguments. The command should
# succeed if the first argument is less than the second argument for the
# purpose of this sort.
#
# If the -0 option is given, input and output are delimited by NUL bytes.
# If the -d option is given, input and output are delimited by the
# character argument.
# Otherwise, they are delimited by newlines.
#
# The ordering is implemented by an insertion sort algorithm.
#
order() {
# Initialize the vars.
local _delimitor=$'\n' _i _j _isDesired=true _comparator=string_ascends _comparator_ascends=1 _top=0 _arrayName= _array=
# Parse the options.
local OPTIND=1
while getopts :0nrRd:f:F:c:C:tT:a: opt; do
case $opt in
0) _delimitor=$'\0' ;;
d) _delimitor=$OPTARG ;;
n) _comparator=number_ascends ;;
R) _comparator=random_ascends ;;
t) _comparator=mtime_ascends ;;
f) _isDesired=$OPTARG ;;
F) _isDesired=bash_desired _bash_desired_code=$OPTARG ;;
c) _comparator=$OPTARG ;;
C) _comparator=bash_ascends _bash_ascends_code=$OPTARG ;;
r) _comparator_ascends=0 ;;
T) _top=$OPTARG ;;
a) _arrayName=$OPTARG _array=$_arrayName[@] ;;
esac
done
shift "$((OPTIND-1))"
# Get the elements.
local _elements=() _element
if [[ $_arrayName ]]; then
for _element in "${!_array}"; do
"$_isDesired" "$_element" && _elements+=("$_element")
done
elif (( $# )); then
for _element; do
"$_isDesired" "$_element" && _elements+=("$_element")
done
else
while IFS= read -r -d "$_delimitor" _element; do
"$_isDesired" "$_element" && _elements+=("$_element")
done
fi
# Iterate in reverse order.
for (( _i = 1; _i < ${#_elements[@]}; ++_i )); do
for (( _j = _i; _j > 0; --_j )); do
_element=${_elements[_j]}
if ( (( _comparator_ascends )) && "$_comparator" "$_element" "${_elements[_j-1]}" ) ||
( (( ! _comparator_ascends )) && ! "$_comparator" "$_element" "${_elements[_j-1]}" ); then
_elements[_j]=${_elements[_j-1]}
_elements[_j-1]=$_element
fi
done
done
(( _top )) || _top=${#_elements[@]}
if [[ $_array ]]; then
declare -ga "$_array=($(printf '%q ' "${_elements[@]:0:_top}"))"
else
printf "%s${_delimitor:-\0}" "${_elements[@]:0:_top}"
fi
} # _____________________________________________________________________
string_ascends() { [[ $1 < $2 ]]; }
number_ascends() { (( $1 < $2 )); }
random_ascends() { (( RANDOM % 2 )); }
mtime_ascends() { [[ $1 -ot $2 ]]; }
exists_desired() { [[ -e $1 ]]; }
line_desired() { [[ $1 ]]; }
code_desired() { line_desired "$1" && ! comment_desired "$1"; }
comment_desired() { line_desired "$1" && [[ $1 = @(#|//|/\*)* ]]; }
bash_desired() { bash -c "$_bash_desired_code" -- "$@"; }
bash_ascends() { bash -c "$_bash_ascends_code" -- "$@"; }
# ______________________________________________________________________
# |__ AddTrap _____________________________________________________________|
#
# addtrap signal command-format [args...]
#
# Add a command to the current commands executed when a signal is received by the bash process.
#
# The command-format is a printf-style format for the command to execute. The optional
# args are interpolated into the command-format by bash's built-in printf.
#
addtrap() {
local signal=$1 cmd=$2; shift 2
printf -v cmd "$cmd" "$@"
read _ _ oldtrap <<< "$(trap -p "$signal")"
eval "declare oldtrap=${oldtrap% *}"
trap "$oldtrap${oldtrap:+; }$cmd" "$signal"
}
# ______________________________________________________________________
# |__ Mutex _____________________________________________________________|
#
# mutex file
#
# Open a mutual exclusion lock on the file, unless another process already owns one.
#
# If the file is already locked by another process, the operation fails.
# This function defines a lock on a file as having a file descriptor open to the file.
# This function uses FD 9 to open a lock on the file. To release the lock, close FD 9:
# exec 9>&-
#
mutex() {
local lockfile=${1:-${BASH_SOURCE[-1]}} pid pids
[[ -e $lockfile ]] || err "No such file: $lockfile" || return
exec 9>> "$lockfile" && [[ $({ fuser -f "$lockfile"; } 2>&- 9>&-) == $$ ]]
}
# ______________________________________________________________________
# |__ PushJob ___________________________________________________________|
#
# pushjob [poolsize] command
#
# Start an asynchronous command within a pool, waiting for space in the pool if it is full.
#
# The pool is pruned automatically as running jobs complete. This function
# allows you to easily run asynchronous commands within a pool of N,
# automatically starting the next command as soon as there's space.
#
pushjob() {
local size=$1; shift 1
# Wait for space in the pool.
until (( ${#jobpool[@]} < size )); do
sleep 1 & pushjobsleep=$!
wait "$pushjobsleep"
done 2>/dev/null
# Register prunejobs and start the pushed job.
trap _prunejobs SIGCHLD
set -m
"$@" & jobpool[$!]=
}
_prunejobs() {
# Prune all pool jobs that are no longer running.
for pid in "${!jobpool[@]}"; do
kill -0 "$pid" 2>/dev/null || unset "jobpool[$pid]"
done
# Unregister SIGCHLD if our pool is empty.
(( ${#jobpool[@]} )) || trap - SIGCHLD
# Wake up pushjob.
kill "$pushjobsleep" 2>/dev/null
}
# ______________________________________________________________________
# |__ FSleep _____________________________________________________________|
#
# fsleep time
#
# Wait for the given (fractional) amount of seconds.
#
# This implementation solves the problem portably, assuming that either
# bash 4.x or a fractional sleep(1) is available.
#
fsleep() {
local fifo=${TMPDIR:-/tmp}/.fsleep.$$
trap 'rm -f "$fifo"' RETURN
mkfifo "$fifo" && { read -t "$1" <> "$fifo" 2>/dev/null || sleep "$1"; }
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ options ___________________________________________________________|
#
# options [option description]...
#
# Specify and handle options in arguments.
#
# The 'setopt' function will be called for each option expected option
# passed to the script, with $1 set to the option character and $2
# its description. Check OPTARG if the option takes an argument.
# 'setopt' will be called with '?' if an invalid option is passed.
#
# Unless specified, the -h option will show a usage description,
# explaining the options.
#
# Proposed usage:
# setopt() {
# case "$1" in
# a) echo "got option a" ;;
# b) echo "got option b with argument $OPTARG" ;;
# esac
# }
# options \
# a 'option a' \
# b: 'option b with argument'
#
options() {
# Parse the expected options and their description.
declare -A options=()
while (( $# )); do
local optchar=$1 optdesc=$2
shift 2 || ftl 'Missing arguments, expected option (%s), description (%s).' "$optchar" "$optdesc" || exit
options[$optchar]=$optdesc
done
# Find the script's options.
local argc=${BASH_ARGC[@]: -1} argv=("${BASH_ARGV[@]: -argc}") arg
local optstring=$(printf %s "${!options[@]}")h
set -- # Sigh. BASH_ARGV is all backwards.
for arg in "${argv[@]}"; do
set -- "$arg" "$@"
done
# Handle the script's options.
while getopts "$optstring" arg; do
if [[ $arg = h && ! ${options[h]} ]]; then
# Show usage message.
[[ -t 1 ]]; local fd=$(( $? + 1 )) optarg
# Print out the app usage.
printf " Usage: $reset$bold%s$reset" "${BASH_SOURCE[1]##*/}" >&$fd
for optchar in "${!options[@]}"; do
[[ $optchar = *: ]] && optarg=" arg" || optarg=
printf " [$bold$green-%s$reset%s]" "${optchar%:}" "$optarg" >&$fd
done
printf "\n\n" >&$fd
# Print out the option descriptions.
for optchar in "${!options[@]}"; do
local optdesc=${options[$optchar]}
[[ $optchar = *: ]] && optarg=" arg" || optarg=
printf " $bold$green-%s$reset%s\t" "${optchar%:}" "$optarg"
fmt -w "$COLUMNS" <<< "${optdesc//+( )/ }" | sed $'1!s/^/ \t/'
printf "\n"
done | column -t -s $'\t' >&$fd
else
optchar=$arg; [[ ! ${options[$arg]} && ${options[$arg:]} ]] && optchar=$arg:
setopt "$arg" "${options[$arg]}"
fi
done
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ ShowHelp __________________________________________________________|
#
# showHelp name description author [option description]...
#
# Generate a prettily formatted usage description of the application.
#
# name Provide the name of the application.
#
# description Provide a detailed description of the application's
# purpose and usage.
#
# option An option the application can take as argument.
#
# description A description of the effect of the preceding option.
#
showHelp() {
# Parse the options.
local appName=$1; shift
local appDesc=${1//+([[:space:]])/ }; shift
local appAuthor=$1; shift
local cols=$(tput cols)
(( cols = ${cols:-80} - 10 ))
# Figure out what FD to use for our messages.
[[ -t 1 ]]; local fd=$(( $? + 1 ))
# Print out the help header.
printf "$reset$bold\n" >&$fd
printf "\t\t%s\n" "$appName" >&$fd
printf "$reset\n" >&$fd
printf "%s\n" "$appDesc" | fmt -w "$cols" | sed $'s/^/\t/' >&$fd
printf "\t $reset$bold~ $reset$bold%s\n" "$appAuthor" >&$fd
printf "$reset\n" >&$fd
# Print out the application options and columnize them.
while (( $# )); do
local optName=$1; shift
local optDesc=$1; shift
printf " %s\t" "$optName"
printf "%s\n" "${optDesc//+( )/ }" | fmt -w "$cols" | sed $'1!s/^/ \t/'
printf "\n"
done | column -t -s $'\t' \
| sed "s/^\( [^ ]*\)/$bold$green\1$reset/" >&$fd
printf "\n" >&$fd
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Quote _____________________________________________________________|
#
# shquote [-e] [argument...]
#
# Shell-quote the arguments to make them safe for injection into bash code.
#
# The result is bash code that represents a series of words, where each
# word is a literal string argument. By default, quoting happens using
# single-quotes.
#
# -e Use backslashes rather than single quotes.
# -d Use double-quotes rather than single quotes (does NOT disable expansions!).
# -a Normally, shquote doesn't quote arguments that don't need it. This forces all arguments to be quoted.
#
shquote() {
# Initialize the defaults.
local OPTIND=1 arg escape=0 sq="'\\''" dq='\"' quotedArgs=() type=single always=0
# Parse the options.
while getopts :eda arg; do
case $arg in
e) type=escape ;;
d) type=double ;;
a) always=1 ;;
esac
done
shift "$((OPTIND-1))"
# Print out each argument, quoting it properly.
for arg; do
(( ! always )) && [[ $arg = "$(printf %q "$arg")" ]] && quotedArgs+=("$arg") && continue
case "$type" in
escape)
quotedArgs+=("$(printf "%q" "$arg")") ;;
single)
arg=${arg//"'"/$sq}
quotedArgs+=("$(printf "'%s'" "$arg")") ;;
double)
arg=${arg//'"'/$dq}
quotedArgs+=("$(printf '"%s"' "$arg")") ;;
esac
done
printf '%s\n' "$(IFS=' '; echo "${quotedArgs[*]}")"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ ReQuote __________________________________________________________|
#
# requote [string]
#
# Escape the argument string to make it safe for injection into a regex.
#
# The result is a regular expression that matches the literal argument
# string.
#
requote() {
# Initialize the defaults.
local char
printf '%s' "$1" | while IFS= read -r -d '' -n1 char; do
printf '[%s]' "$char"
done
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Shorten ___________________________________________________________|
#
# shorten [-p pwd] path [suffix]...
#
# Shorten an absolute path for pretty printing.
# Paths are shortened by replacing the homedir by ~, making it relative and
# cutting off given suffixes from the end.
#
# -p Use the given pathname as the base for relative filenames instead of PWD.
# path The path string to shorten.
# suffix Suffix strings that must be cut off from the end.
# Only the first suffix string matched will be cut off.
#
shorten() {
# Parse the options.
local suffix path pwd=$PWD
[[ $1 = -p ]] && { pwd=$2; shift 2; }
path=$1; shift
# Make path absolute.
[[ $path = /* ]] || path=$PWD/$path
# If the path denotes something that exists; it's easy.
if [[ -d $path ]]
then path=$(cd "$path"; printf "%s" "$PWD")
elif [[ -d ${path%/*} ]]
then path=$(cd "${path%/*}"; printf "%s" "$PWD/${path##*/}")
# If not, we'll try readlink -m.
elif readlink -m / >/dev/null 2>&1; then
path=$(readlink -m "$path")
# If we don't have that - unleash the sed(1) madness.
else
local oldpath=/
while [[ $oldpath != $path ]]; do
oldpath=$path
path=$(sed -e 's,///*,/,g' -e 's,\(^\|/\)\./,\1,g' -e 's,\(^\|/\)[^/]*/\.\.\($\|/\),\1,g' <<< "$path")
done
fi
# Replace special paths.
path=${path/#$HOME/'~'}
path=${path#$pwd/}
# Cut off suffix.
for suffix; do
[[ $path = *$suffix ]] && {
path=${path%$suffix}
break
}
done
printf "%s" "$path"
} # _____________________________________________________________________
Make mpw_mkpw symlinkable.
2017-10-06 17:33:08 +00:00
# ______________________________________________________________________
# |__ CdSource ________________________________________________________________|
#
# cdsource [file]
#
# Change the current directory into the directory where the file is located, resolving symlinks.
#
cdsource() {
local source=${1:-${BASH_SOURCE[1]}}
while [[ $source ]]; do
[[ $source = */* ]] && cd "${source%/*}"
if [[ -L ${source##*/} ]]; then
source=$(readlink "${source##*/}")
else
source=
fi
done
} # _____________________________________________________________________
Added bashlib.
2017-09-14 20:44:32 +00:00
# ______________________________________________________________________
# |__ Up ________________________________________________________________|
#
# up .../path|num
#
# Walk the current working directory up towards root num times or until path is found.
#
# Returns 0 if the destination was reached or 1 if we hit root.
#
# Prints PWD on stdout on success.
#
up() {
local up=0
until [[ $PWD = / ]]; do
cd ../
if [[ $1 = .../* ]]; then
[[ -e ${1#.../} ]] && pwd && return
elif (( ++up == $1 )); then
pwd && return
fi
done
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ BuildArray ________________________________________________________|
#
# buildarray name terms... -- elements...
#
# Create an array by adding all the terms to it for each element, replacing {} terms by the element.
#
# name The name of the array to put the result into.
# terms The values to add to the array for each of the elements. A {} term is replaced by the current element.
# elements The elements to iterate the terms for.
#
buildarray() {
local target=$1 term terms=() element value
shift
while [[ $1 != -- ]]; do
terms+=("$1")
shift
done
shift
for element; do
for term in "${terms[@]}"; do
[[ $term = {} ]] && value="$element" || value="$term"
declare -ag "$target+=($(printf '%q' "$value"))"
done
done
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ InArray ___________________________________________________________|
#
# inArray element array
#
# Checks whether a certain element is in the given array.
#
# element The element to search the array for.
# array This is a list of elements to search through.
#
inArray() {
# Parse the options.
local element
local search=$1; shift
# Perform the search.
for element
do [[ $element = $search ]] && return 0; done
return 1
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ HideDebug _________________________________________________________|
#
# hideDebug [on|off]
#
# Toggle Bash's debugging mode off temporarily.
# To hide Bash's debugging output for a function, you should have
# hideDebug on
# as its first line, and
# hideDebug off
# as its last.
#
hideDebug() {
if [[ $1 = on ]]; then
: -- HIDING DEBUG OUTPUT ..
[[ $- != *x* ]]; bashlib_debugWasOn=$?
set +x
elif [[ $1 = off ]]; then
: -- SHOWING DEBUG OUTPUT ..
(( bashlib_debugWasOn )) && \
set -x
fi
}
# ______________________________________________________________________
# |__ anfunc ____________________________________________________________|
#
# anfunc [on|off]
#
# Turn on or off support for annonymous functions.
#
# WARNING: This is a hack. It turns on extdebug and causes any argument
# that matches (){code} to be replaced by a function name that if invoked
# runs code.
#
# eg.
# confirm '(){ rm "$1" }' *.txt
# # In this example, confirm() could be a function that asks confirmation
# # for each argument past the first and runs the anfunc in the first
# # argument on each confirmed argument.
#
# Don't use this. It is an academic experiment and has bugs.
#
# Bugs:
# - commands lose their exit code.
# To inhibit the real command from running, we use extdebug and
# a DEBUG trap that returns non-0. As a result, the actual return
# code is lost.
#
anfunc() {
case "$1" in
on)
shopt -s extdebug
trap _anfunc_trap DEBUG
;;
off)
trap - DEBUG
shopt -u extdebug
;;
esac
}
_anfunc_trap() {
local f w
# Perform the command parsing and handling up to its word splitting.
# This includes command substitution, quote handling, pathname expansion, etc.
declare -a words="($BASH_COMMAND)"
# Iterate the words to run in the final stage, and handle anfunc matches.
for ((w=0; w<${#words[@]}; ++w)); do
[[ ${words[w]} = '(){'*'}' ]] &&
# Declare a new function for this anfunc.
eval "_f$((++f))${words[w]}" &&
# Replace the word by the new function's name.
words[w]="_f$f"
done
# Run the command.
eval "$(printf '%q ' "${words[@]}")"
# Clean up the anfuncs.
for ((; f>0; --f)); do
unset -f "_f$f"
done
# Inhibit the real command's execution.
return 1
}
# ______________________________________________________________________
# |__ StackTrace ________________________________________________________|
#
# stackTrace
#
# Output the current script's function execution stack.
#
stackTrace() {
# Some general debug information.
wrn " [PID : %15s] [PPID : %8s] [Main PID : %8s]" "$BASHPID" "$PPID" "$$"
wrn " [Level : %15s] [Subshells : %8s] [Runtime : %7ss]" "$SHLVL" "$BASH_SUBSHELL" "$SECONDS"
wrn " [Locale : %15s] [IFS : %8s]" "${LC_ALL:-${LC_COLLATE:-${LANG:-C}}}" "$(printf %q "$IFS")"
wrn " Dir Stack : %s" "${DIRSTACK[*]}"
wrn " Shell : %s v%s" "$BASH" "$BASH_VERSION"
wrn " Shell Opts : %s" "${SHELLOPTS//:/, }"
wrn " Bash Opts : %s" "${BASHOPTS//:/, }"
wrn " Functions :"
# Search through the map.
local arg=0
for stack in "${!FUNCNAME[@]}"; do
(( stack+1 >= ${#BASH_SOURCE[@]} )) && break
func=${FUNCNAME[stack]}
line=${BASH_LINENO[stack]}
file=${BASH_SOURCE[stack+1]}
args=()
for (( arg=0, s=0; s <= stack; ++s )); do
for (( sarg=0; sarg < ${BASH_ARGC[s]:-0}; ++sarg, ++arg )); do
(( s == stack )) && args[${BASH_ARGC[s]} - sarg]=${BASH_ARGV[arg]}
done
done
wrn '%40s:%-3d | %s %s' "$file" "$line" "$func" "$(printf '%s ' "$(shquote "${args[@]}")")"
done
} # _____________________________________________________________________
# ______________________________________________________________________
# | |
# | .: ENTRY POINT :. |
# |______________________________________________________________________|
# Make sure this file is sourced and not executed.
( return 2>/dev/null ) || {
help=$(sed -n '1,/_tocHash=/{ /^#/p; }' "$BASH_SOURCE")
if [[ $1 ]]; then
while [[ $1 ]]; do
awk "p && !/^# *[^ ]/ {exit}
p || /^# $1/ {print; p=1}" <<< "$help"
shift
done
else
echo "$help"
echo
echo "To use bashlib, copy it into your PATH and put ''source bashlib'' at the top of your script."
fi
}
:
: .: END SOURCING :.
: ______________________________________________________________________
:
Copy Permalink