1 |
8291
|
aaronmk
|
#!/bin/bash -e
|
2 |
9328
|
aaronmk
|
set -o errexit -o pipefail # errexit in case caller's #! line missing -e
|
3 |
8952
|
aaronmk
|
|
4 |
9018
|
aaronmk
|
if test ! "$_util_sh_include_guard_utils"; then
|
5 |
|
|
_util_sh_include_guard_utils=1
|
6 |
|
|
|
7 |
9798
|
aaronmk
|
isset() { declare -p "$1" &>/dev/null; }
|
8 |
9002
|
aaronmk
|
|
9 |
9074
|
aaronmk
|
realpath() { readlink -f -- "$1"; }
|
10 |
8703
|
aaronmk
|
|
11 |
9314
|
aaronmk
|
str2varname() { echo "${1//[^a-zA-Z0-9_]/_}"; }
|
12 |
8716
|
aaronmk
|
|
13 |
9312
|
aaronmk
|
include_guard_var() { str2varname "$(realpath "$1")"; }
|
14 |
|
|
|
15 |
9074
|
aaronmk
|
self_not_included() # usage: if self_not_included; then ... fi
|
16 |
8703
|
aaronmk
|
{
|
17 |
8971
|
aaronmk
|
test $# -ge 1 || set -- "${BASH_SOURCE[1]}"
|
18 |
8703
|
aaronmk
|
local include_guard="$(include_guard_var "$1")"
|
19 |
8793
|
aaronmk
|
alias self_being_included=false
|
20 |
9003
|
aaronmk
|
! isset "$include_guard" && \
|
21 |
8793
|
aaronmk
|
{ eval "$include_guard"=1; alias self_being_included=true; }
|
22 |
8703
|
aaronmk
|
}
|
23 |
|
|
|
24 |
8793
|
aaronmk
|
# to load newly-defined aliases for use in functions in the same file:
|
25 |
|
|
## fi # load new aliases
|
26 |
|
|
## if self_being_included; then
|
27 |
|
|
# this is needed because aliases defined inside an if statement are not
|
28 |
|
|
# available inside that if statement
|
29 |
|
|
|
30 |
9018
|
aaronmk
|
fi
|
31 |
9017
|
aaronmk
|
|
32 |
9018
|
aaronmk
|
|
33 |
8704
|
aaronmk
|
if self_not_included "${BASH_SOURCE[0]}"; then
|
34 |
|
|
|
35 |
9017
|
aaronmk
|
|
36 |
|
|
#### options
|
37 |
|
|
|
38 |
8709
|
aaronmk
|
shopt -s expand_aliases
|
39 |
|
|
|
40 |
9017
|
aaronmk
|
|
41 |
9789
|
aaronmk
|
#### stubs
|
42 |
|
|
|
43 |
9794
|
aaronmk
|
__caller_indent='log_indent="$log_indent$log_indent_step"'
|
44 |
|
|
alias caller_indent="$__caller_indent"
|
45 |
|
|
alias indent="declare $__caller_indent"
|
46 |
|
|
|
47 |
9789
|
aaronmk
|
function echo_func() { :; }
|
48 |
9790
|
aaronmk
|
alias echo_func='"echo_func" "$FUNCNAME" "$@" && indent || true'
|
49 |
9789
|
aaronmk
|
|
50 |
9796
|
aaronmk
|
function echo_run() { :; }
|
51 |
|
|
alias echo_run='"echo_run" ' # last space alias-expands next word
|
52 |
9789
|
aaronmk
|
|
53 |
10017
|
aaronmk
|
# auto-echo common external commands
|
54 |
10018
|
aaronmk
|
for cmd in env rm which; do alias "$cmd=echo_run $cmd"; done; unset cmd
|
55 |
10017
|
aaronmk
|
|
56 |
10044
|
aaronmk
|
echo_builtin() { :; }
|
57 |
|
|
|
58 |
9797
|
aaronmk
|
function echo_vars() { :; }
|
59 |
9796
|
aaronmk
|
|
60 |
9797
|
aaronmk
|
|
61 |
9226
|
aaronmk
|
#### vars
|
62 |
|
|
|
63 |
|
|
set_var() { eval "$1"'="$2"'; }
|
64 |
|
|
|
65 |
9420
|
aaronmk
|
set_default() { if ! isset "$1"; then set_var "$@"; fi; }
|
66 |
|
|
|
67 |
9226
|
aaronmk
|
set_inv() { set_var no_"$1" "$(test "${!1}" || echo 1)"; }
|
68 |
|
|
|
69 |
|
|
# usage: local var=...; local_inv
|
70 |
|
|
alias local_inv='declare "no_$var=$(test "${!var}" || echo 1)"'
|
71 |
|
|
|
72 |
9227
|
aaronmk
|
unexport() { export -n "$@"; }
|
73 |
|
|
# `declare +x` won't work because it defines the var if it isn't set
|
74 |
|
|
|
75 |
9236
|
aaronmk
|
alias local_export='declare -x' # combines effects of local and export
|
76 |
|
|
|
77 |
9226
|
aaronmk
|
get_prefix_vars() { : "${prefix:?}"; eval echo '${!'$prefix'*}'; }
|
78 |
|
|
|
79 |
|
|
# usage: local prefix=..._; import_vars
|
80 |
|
|
# when used inside another alias 2+ levels deep, *must* be run inside a function
|
81 |
|
|
alias import_vars="$(cat <<'EOF'
|
82 |
|
|
: "${prefix:?}"
|
83 |
|
|
declare src_var dest_var
|
84 |
|
|
for src_var in $(get_prefix_vars); do
|
85 |
|
|
dest_var="${src_var#$prefix}"
|
86 |
|
|
declare "$dest_var=${!src_var}"; echo_vars "$dest_var"
|
87 |
|
|
done
|
88 |
|
|
EOF
|
89 |
|
|
)"
|
90 |
|
|
|
91 |
|
|
|
92 |
9311
|
aaronmk
|
#### caching
|
93 |
|
|
|
94 |
|
|
## shell-variable-based caching
|
95 |
|
|
|
96 |
9330
|
aaronmk
|
# usage: local cache_key=...; load_cache; \
|
97 |
9331
|
aaronmk
|
# if ! cached; then save_cache value || return; fi; echo_cached_value
|
98 |
9561
|
aaronmk
|
# cache_key for function inputs: "$(declare -p kw_param...) $*"
|
99 |
9311
|
aaronmk
|
alias load_cache='declare cache_var="$(str2varname "${FUNCNAME}___$cache_key")"'
|
100 |
|
|
alias cached='isset "$cache_var"'
|
101 |
|
|
alias save_cache='set_var "$cache_var"'
|
102 |
|
|
alias echo_cached_value='echo "${!cache_var}"'
|
103 |
|
|
|
104 |
|
|
clear_cache() # usage: func=... clear_cache
|
105 |
|
|
{ : "${func:?}"; unset $(prefix="${func}___" get_prefix_vars); }
|
106 |
|
|
|
107 |
|
|
fi # load new aliases
|
108 |
|
|
if self_being_included; then
|
109 |
|
|
|
110 |
|
|
|
111 |
9017
|
aaronmk
|
#### aliases
|
112 |
|
|
|
113 |
9074
|
aaronmk
|
unalias() { builtin unalias "$@" 2>&- || true; } # no error if undefined
|
114 |
8889
|
aaronmk
|
|
115 |
9191
|
aaronmk
|
# usage: alias alias_='var=value run_cmd '
|
116 |
|
|
function run_cmd() { "$@"; }
|
117 |
|
|
alias run_cmd='"run_cmd" ' # last space alias-expands next word
|
118 |
9017
|
aaronmk
|
|
119 |
9688
|
aaronmk
|
alias_append() { eval $(alias "$1")'"$2"'; } # usage: alias_append alias '; cmd'
|
120 |
9191
|
aaronmk
|
|
121 |
9688
|
aaronmk
|
|
122 |
10045
|
aaronmk
|
#### commands
|
123 |
|
|
|
124 |
10063
|
aaronmk
|
sys_cmd_path() { echo_func; echo_builtin command -p which "$1"|echo_stdout; }
|
125 |
|
|
|
126 |
10045
|
aaronmk
|
# makes command in $1 a system command
|
127 |
|
|
# allows running a system command of the same name as the script
|
128 |
|
|
alias cmd2sys="$(cat <<'EOF'
|
129 |
|
|
declare _1="$1"; shift
|
130 |
10063
|
aaronmk
|
_1="$(indent; clog++ sys_cmd_path "$_1")" || return
|
131 |
10045
|
aaronmk
|
set -- "$_1" "$@"
|
132 |
|
|
EOF
|
133 |
|
|
)"
|
134 |
|
|
|
135 |
|
|
fi # load new aliases
|
136 |
|
|
if self_being_included; then
|
137 |
|
|
|
138 |
|
|
sys_cmd() { cmd2sys; command "$@"; } # usage: sys_cmd cmd... # runs system cmd
|
139 |
|
|
# allows running a system command of the same name as the script
|
140 |
|
|
|
141 |
|
|
|
142 |
9082
|
aaronmk
|
#### functions
|
143 |
|
|
|
144 |
9235
|
aaronmk
|
kw_params() # usage: func() { kw_params param_var...; }; ...; param_var=... cmd
|
145 |
9229
|
aaronmk
|
# removes keyword-param-only vars from the environment
|
146 |
|
|
{ unexport "$@"; }
|
147 |
9228
|
aaronmk
|
|
148 |
9799
|
aaronmk
|
# usage: cmd=... foreach_arg
|
149 |
|
|
function foreach_arg()
|
150 |
|
|
{
|
151 |
9808
|
aaronmk
|
echo_func; kw_params cmd; : "${cmd:?}"
|
152 |
|
|
local a; for a in "$@"; do
|
153 |
9806
|
aaronmk
|
a="$(clog++ echo_run "$cmd" "$a")" || return; args+=("$a")
|
154 |
|
|
done
|
155 |
9799
|
aaronmk
|
echo_vars args
|
156 |
|
|
}
|
157 |
|
|
alias foreach_arg='"foreach_arg" "$@"; set -- "${args[@]}"; unset args'
|
158 |
|
|
|
159 |
10064
|
aaronmk
|
alias self_name='echo "${FUNCNAME%%__*}"' # usage: "$(self_name)"
|
160 |
9082
|
aaronmk
|
|
161 |
10064
|
aaronmk
|
alias self='command "$(self_name)"' # usage: wrapper() { self ...; }
|
162 |
|
|
alias self_sys='sys_cmd "$(self_name)"' # wrapper() { self_sys ...; }
|
163 |
|
|
|
164 |
9678
|
aaronmk
|
pf() { declare -f "$@"; } # usage: pf function # prints func decl for debugging
|
165 |
9082
|
aaronmk
|
|
166 |
9677
|
aaronmk
|
all_funcs() # usage: for func in $(all_funcs); do ...; done # all declared funcs
|
167 |
|
|
{ declare -F|while read -r line; do echo -n "${line#declare -f } "; done; }
|
168 |
9673
|
aaronmk
|
|
169 |
9677
|
aaronmk
|
|
170 |
8886
|
aaronmk
|
#### exceptions
|
171 |
|
|
|
172 |
9032
|
aaronmk
|
# usage: cmd || { save_e; ...; rethrow; }
|
173 |
9031
|
aaronmk
|
alias export_e='e=$?'
|
174 |
9032
|
aaronmk
|
alias save_e='declare e=$?'
|
175 |
8976
|
aaronmk
|
alias rethrow='return "$e"'
|
176 |
|
|
alias rethrow_subshell='exit "$e"'
|
177 |
|
|
|
178 |
8978
|
aaronmk
|
fi # load new aliases
|
179 |
|
|
if self_being_included; then
|
180 |
|
|
|
181 |
9535
|
aaronmk
|
# usage: try cmd...; ignore_e status; if catch status; then ...; fi; end_try
|
182 |
8886
|
aaronmk
|
|
183 |
9448
|
aaronmk
|
function try() { e=0; benign_error=1 "$@" || { export_e; true; }; }
|
184 |
9177
|
aaronmk
|
alias try='declare e; "try" ' # last space alias-expands next word
|
185 |
8886
|
aaronmk
|
|
186 |
9534
|
aaronmk
|
catch() { test "$e" -eq "$1" && e=0; }
|
187 |
8886
|
aaronmk
|
|
188 |
9535
|
aaronmk
|
ignore_e() { catch "$@" || true; }
|
189 |
8886
|
aaronmk
|
|
190 |
8977
|
aaronmk
|
alias end_try='rethrow'
|
191 |
|
|
alias end_try_subshell='rethrow_subshell'
|
192 |
8886
|
aaronmk
|
|
193 |
9536
|
aaronmk
|
ignore() { save_e; ignore_e "$@"; rethrow; } # usage: try cmd || ignore status
|
194 |
|
|
|
195 |
9551
|
aaronmk
|
### signals
|
196 |
|
|
|
197 |
|
|
sig_e() { echo $(( 128+$(kill -l "$1") )); } # usage: sig_e SIGINT, etc.
|
198 |
|
|
|
199 |
|
|
ignore_sig() { ignore "$(sig_e "$1")"; }
|
200 |
|
|
|
201 |
9678
|
aaronmk
|
# usage: piped_cmd cmd1...|cmd2... # cmd2 doesn't read all its input
|
202 |
9551
|
aaronmk
|
function piped_cmd() { "$@" || ignore_sig SIGPIPE; }
|
203 |
|
|
alias piped_cmd='"piped_cmd" ' # last space alias-expands next word
|
204 |
|
|
|
205 |
9020
|
aaronmk
|
fi # load new aliases
|
206 |
|
|
if self_being_included; then
|
207 |
9017
|
aaronmk
|
|
208 |
9020
|
aaronmk
|
|
209 |
8899
|
aaronmk
|
#### integers
|
210 |
|
|
|
211 |
9074
|
aaronmk
|
let!() { let "$@" || true; } # always returns true; safe to use for setting
|
212 |
8899
|
aaronmk
|
# "If the last ARG evaluates to 0, let returns 1" (`help let`)
|
213 |
|
|
|
214 |
9074
|
aaronmk
|
bool2int() { try test ! "$1"; echo "$e"; } # empty->0; non-empty->1
|
215 |
9004
|
aaronmk
|
|
216 |
9696
|
aaronmk
|
int2exit() { (( "$1" != 0 )); }
|
217 |
9017
|
aaronmk
|
|
218 |
9697
|
aaronmk
|
exit2bool() { if (( $? == 0 )); then echo 1; fi } # 0->non-empty; !=0->empty
|
219 |
9538
|
aaronmk
|
|
220 |
9697
|
aaronmk
|
|
221 |
9364
|
aaronmk
|
#### floats
|
222 |
|
|
|
223 |
|
|
int_part() { echo "${1%%.*}"; }
|
224 |
|
|
|
225 |
|
|
dec_suffix() { echo "${1#$(int_part "$1")}"; }
|
226 |
|
|
|
227 |
|
|
round_down() { int_part "$1"; }
|
228 |
|
|
|
229 |
|
|
float+int() { echo "$(($(int_part "$1")+$2))$(dec_suffix "$1")"; }
|
230 |
|
|
|
231 |
9544
|
aaronmk
|
float_set_min() { if (($(int_part $1) >= $2)); then echo $1; else echo $2; fi; }
|
232 |
9364
|
aaronmk
|
|
233 |
9544
|
aaronmk
|
|
234 |
9079
|
aaronmk
|
#### strings
|
235 |
|
|
|
236 |
9653
|
aaronmk
|
starts_with() { test "${2#$1}" != "$2"; } # usage: starts_with pattern str
|
237 |
|
|
|
238 |
9711
|
aaronmk
|
match_prefix() # usage: match_prefix pattern str
|
239 |
|
|
{ if starts_with "$1" "$2"; then echo "${2%${2#$1}}"; fi }
|
240 |
|
|
|
241 |
9081
|
aaronmk
|
repeat() # usage: str=... n=... repeat
|
242 |
|
|
{
|
243 |
9304
|
aaronmk
|
: "${str?}" "${n:?}"; local result= n="$n" # n will be modified in function
|
244 |
|
|
for (( ; n > 0; n-- )); do result="$result$str"; done
|
245 |
|
|
echo "$result"
|
246 |
9081
|
aaronmk
|
}
|
247 |
|
|
|
248 |
10217
|
aaronmk
|
sed_cmd="env LANG= sed -`case "$(uname)" in Darwin) echo E;; *) echo r;; esac`"
|
249 |
|
|
# LANG: avoid invalid UTF-8 "illegal byte sequence" errors when LANG=*.UTF-8
|
250 |
|
|
alias sed="$sed_cmd"
|
251 |
|
|
# can't be function because this causes segfault in redir() subshell when
|
252 |
|
|
# used with make.sh make() filter
|
253 |
9079
|
aaronmk
|
|
254 |
9366
|
aaronmk
|
fi # load new aliases
|
255 |
|
|
if self_being_included; then
|
256 |
9079
|
aaronmk
|
|
257 |
9425
|
aaronmk
|
rtrim() { log+ 3; sed 's/[[:space:]]+$//' <<<"$1"; }
|
258 |
9079
|
aaronmk
|
|
259 |
9085
|
aaronmk
|
|
260 |
8854
|
aaronmk
|
#### arrays
|
261 |
8694
|
aaronmk
|
|
262 |
9938
|
aaronmk
|
echo1() { echo "$1"; } # usage: echo1 values...
|
263 |
|
|
|
264 |
10019
|
aaronmk
|
# usage: split delim str; use ${parts[@]}
|
265 |
|
|
function split() { echo_func; local IFS="$1"; parts=($2); echo_vars parts; }
|
266 |
|
|
alias split='declare parts; "split"'
|
267 |
|
|
|
268 |
9074
|
aaronmk
|
join() { local IFS="$delim"; echo "$*"; } # usage: delim=... join elems...
|
269 |
8816
|
aaronmk
|
|
270 |
9074
|
aaronmk
|
reverse() # usage: array=($(reverse args...))
|
271 |
8691
|
aaronmk
|
{
|
272 |
|
|
local i
|
273 |
9080
|
aaronmk
|
for (( i=$#; i > 0; i-- )); do printf '%q ' "${!i}"; done
|
274 |
8691
|
aaronmk
|
}
|
275 |
|
|
|
276 |
9097
|
aaronmk
|
contains() # usage: contains value in_array...
|
277 |
|
|
{
|
278 |
|
|
local value="$1"; shift
|
279 |
|
|
local elem
|
280 |
|
|
for elem in "$@"; do if test "$elem" = "$value"; then return 0; fi; done
|
281 |
|
|
return 1
|
282 |
|
|
}
|
283 |
9017
|
aaronmk
|
|
284 |
10400
|
aaronmk
|
is_array()
|
285 |
|
|
{
|
286 |
|
|
local decl; decl="$(declare -p "$1")" || return; echo_vars decl
|
287 |
|
|
starts_with 'declare -a' "$decl" # also matches -ax
|
288 |
|
|
}
|
289 |
|
|
|
290 |
9715
|
aaronmk
|
#### streams
|
291 |
9097
|
aaronmk
|
|
292 |
9715
|
aaronmk
|
pipe_delay() # usage: cmd1 | { pipe_delay; cmd2; }
|
293 |
|
|
{ sleep 0.1; } # s; display after leading output of cmd1
|
294 |
|
|
|
295 |
|
|
|
296 |
8854
|
aaronmk
|
#### verbose output
|
297 |
|
|
|
298 |
9110
|
aaronmk
|
|
299 |
9208
|
aaronmk
|
err_fd=2 # stderr
|
300 |
|
|
|
301 |
9111
|
aaronmk
|
usage() { echo "Usage: $1" >&2; return 2; }
|
302 |
9110
|
aaronmk
|
|
303 |
|
|
|
304 |
9452
|
aaronmk
|
### log++
|
305 |
9110
|
aaronmk
|
|
306 |
9361
|
aaronmk
|
log_fd=2 # initially stderr
|
307 |
9209
|
aaronmk
|
|
308 |
9142
|
aaronmk
|
if test "$explicit_errors_only"; then verbosity=0; fi # hide startup logging
|
309 |
|
|
|
310 |
9006
|
aaronmk
|
# set verbosity
|
311 |
9005
|
aaronmk
|
if isset verbose; then : "${verbosity:=$(bool2int "$verbose")}"; fi
|
312 |
9145
|
aaronmk
|
if isset vb; then : "${verbosity:=$vb}"; fi
|
313 |
9272
|
aaronmk
|
: "${verbosity=1}" # default
|
314 |
9006
|
aaronmk
|
: "${verbosity:=0}" # ensure non-empty
|
315 |
9119
|
aaronmk
|
export verbosity # propagate to invoked commands
|
316 |
9381
|
aaronmk
|
export PS4 # follows verbosity, so also propagate this
|
317 |
8710
|
aaronmk
|
|
318 |
9731
|
aaronmk
|
is_outermost="$(! isset log_level; exit2bool)" # if util.sh env not yet set up
|
319 |
|
|
|
320 |
9542
|
aaronmk
|
# set log_level
|
321 |
|
|
: "${log_level=$(( ${#PS4}-1 ))}" # defaults to # non-space symbols in PS4
|
322 |
|
|
export log_level # propagate to invoked commands
|
323 |
|
|
|
324 |
9396
|
aaronmk
|
verbosity_int() { round_down "$verbosity"; }
|
325 |
|
|
|
326 |
9450
|
aaronmk
|
# verbosities (and `make` equivalents):
|
327 |
9359
|
aaronmk
|
# 0: just print errors. useful for cron jobs.
|
328 |
9451
|
aaronmk
|
# vs. make: equivalent to --silent, but suppresses external command output
|
329 |
9359
|
aaronmk
|
# 1: also external commands run. useful for running at the command line.
|
330 |
9450
|
aaronmk
|
# vs. make: not provided (but sorely needed to avoid excessive output)
|
331 |
9359
|
aaronmk
|
# 2: full graphical call tree. useful for determining where error occurred.
|
332 |
9450
|
aaronmk
|
# vs. make: equivalent to default verbosity, but with much-needed indents
|
333 |
9360
|
aaronmk
|
# 3: also values of kw params and variables. useful for low-level debugging.
|
334 |
9450
|
aaronmk
|
# vs. make: not provided; need to manually use $(error $(var))
|
335 |
9359
|
aaronmk
|
# 4: also variables in util.sh commands. useful for debugging util.sh.
|
336 |
9450
|
aaronmk
|
# vs. make: somewhat similar to --print-data-base
|
337 |
9359
|
aaronmk
|
# 5: also variables in logging commands themselves. useful for debugging echo_*.
|
338 |
9450
|
aaronmk
|
# vs. make: not provided; need to search Makefile for @ at beginning of cmd
|
339 |
9359
|
aaronmk
|
# 6+: not currently used (i.e. same as 5)
|
340 |
|
|
|
341 |
9287
|
aaronmk
|
# definition: the log_level is the minimum verbosity needed to display a message
|
342 |
|
|
# for messages that use can_log(), the log_level starts with *1*, not 0
|
343 |
|
|
# for unfiltered messages, the log_level is 0 (i.e. still output at verbosity=0)
|
344 |
9288
|
aaronmk
|
# to view a message's log_level, count the # of + signs before it in the output
|
345 |
9284
|
aaronmk
|
|
346 |
9305
|
aaronmk
|
fi # load new aliases
|
347 |
|
|
if self_being_included; then
|
348 |
|
|
|
349 |
9299
|
aaronmk
|
# usage: in func: log++; ... OR log_local; "log++"; ...
|
350 |
9176
|
aaronmk
|
# outside func: log++; ...; log--
|
351 |
9720
|
aaronmk
|
# before cmd: "log++" cmd OR "log+" # cmd OR "log++" "log++" cmd
|
352 |
9716
|
aaronmk
|
# with a cmd, assignments are applied just to it, so log_local is not needed
|
353 |
9302
|
aaronmk
|
# without a cmd, "$@" expands to nothing and assignments are applied to caller
|
354 |
9305
|
aaronmk
|
# "${@:2}" expands to all of $@ after *1st* arg, not 2nd ($@ indexes start at 1)
|
355 |
9373
|
aaronmk
|
log+()
|
356 |
|
|
{
|
357 |
|
|
# no local vars because w/o cmd, assignments should be applied to caller
|
358 |
9545
|
aaronmk
|
PS4="$(str="${PS4:0:1}" n=$((log_level+$1-1)) repeat)${PS4: -2}"; \
|
359 |
9543
|
aaronmk
|
log_level=$((log_level+$1)) \
|
360 |
9377
|
aaronmk
|
verbosity="$(float+int "$verbosity" "-$1")" "${@:2}"
|
361 |
9373
|
aaronmk
|
}
|
362 |
10153
|
aaronmk
|
log-() { log+ "-$1" "${@:2}"; }
|
363 |
10154
|
aaronmk
|
log++() { log+ 1 "$@"; }
|
364 |
|
|
log--() { log- 1 "$@"; }
|
365 |
9542
|
aaronmk
|
alias log_local=\
|
366 |
|
|
'declare PS4="$PS4" log_level="$log_level" verbosity="$verbosity"'
|
367 |
9395
|
aaronmk
|
alias log+='log_local; "log+"' # don't expand next word because it's not a cmd
|
368 |
9301
|
aaronmk
|
alias log++='log_local; "log++" ' # last space alias-expands next word
|
369 |
|
|
alias log--='log_local; "log--" ' # last space alias-expands next word
|
370 |
9751
|
aaronmk
|
# no clog+ alias because next word is not a cmd
|
371 |
|
|
alias clog++='"log++" ' # last space alias-expands next word
|
372 |
|
|
alias clog--='"log--" ' # last space alias-expands next word
|
373 |
9176
|
aaronmk
|
|
374 |
9846
|
aaronmk
|
verbosity_min() # usage: verbosity_min {min|} # ''->verbosity=''
|
375 |
|
|
{ if test ! "$1" -o "$(verbosity_int)" -lt "$1"; then verbosity="$1"; fi; }
|
376 |
9397
|
aaronmk
|
alias verbosity_min='log_local; "verbosity_min"'
|
377 |
9289
|
aaronmk
|
|
378 |
9878
|
aaronmk
|
# usage: (verbosity_compat; cmd)
|
379 |
9867
|
aaronmk
|
function verbosity_compat()
|
380 |
9878
|
aaronmk
|
{ echo_func; if ((verbosity == 1)); then unset verbosity; fi; }
|
381 |
9867
|
aaronmk
|
alias verbosity_compat='declare verbosity; "verbosity_compat"'
|
382 |
9397
|
aaronmk
|
|
383 |
9867
|
aaronmk
|
|
384 |
9289
|
aaronmk
|
# indent for call tree. this is *not* the log_level (below).
|
385 |
9382
|
aaronmk
|
: "${log_indent_step=| }" "${log_indent=}"
|
386 |
|
|
export log_indent_step log_indent # propagate to invoked commands
|
387 |
9289
|
aaronmk
|
|
388 |
9794
|
aaronmk
|
# see indent alias in stubs
|
389 |
9289
|
aaronmk
|
|
390 |
|
|
|
391 |
9190
|
aaronmk
|
fi # load new aliases
|
392 |
|
|
if self_being_included; then
|
393 |
|
|
|
394 |
9396
|
aaronmk
|
can_log() { test "$(verbosity_int)" -gt 0; }
|
395 |
9380
|
aaronmk
|
# verbosity=0 turns off all logging
|
396 |
8895
|
aaronmk
|
|
397 |
9212
|
aaronmk
|
log() { if can_log; then echo "$log_indent$PS4$1" >&"$log_fd"; fi; }
|
398 |
9064
|
aaronmk
|
|
399 |
9270
|
aaronmk
|
log_custom() # usage: symbol=... log_custom msg
|
400 |
9242
|
aaronmk
|
{ log_indent="${log_indent//[^ ]/$symbol}" PS4="${PS4//[^ ]/$symbol}" log "$@";}
|
401 |
9070
|
aaronmk
|
|
402 |
9251
|
aaronmk
|
log_err() { symbol='#' verbosity=1 log_fd="$err_fd" log_custom "$@"; }
|
403 |
9070
|
aaronmk
|
|
404 |
9250
|
aaronmk
|
log_info() { symbol=: log_custom "$@"; }
|
405 |
9070
|
aaronmk
|
|
406 |
9678
|
aaronmk
|
die() # usage: cmd || [type=...] die msg # msg can use $? but not $()
|
407 |
9270
|
aaronmk
|
{ save_e; kw_params type; "log_${type:-err}" "$1"; rethrow; }
|
408 |
9069
|
aaronmk
|
|
409 |
9447
|
aaronmk
|
die_e() # usage: cmd || [benign_error=1] die_e [|| handle error]
|
410 |
|
|
{
|
411 |
|
|
save_e; kw_params benign_error
|
412 |
9449
|
aaronmk
|
if test "$benign_error"; then log++; fi
|
413 |
9447
|
aaronmk
|
type="${benign_error:+info}" die "command exited with \
|
414 |
|
|
$(if test "$benign_error"; then echo status; else echo error; fi) $e"
|
415 |
|
|
rethrow
|
416 |
|
|
}
|
417 |
8919
|
aaronmk
|
|
418 |
9437
|
aaronmk
|
|
419 |
9233
|
aaronmk
|
#### functions
|
420 |
|
|
|
421 |
|
|
func_exists() { declare -f "$1" >/dev/null; }
|
422 |
|
|
|
423 |
|
|
copy_func() # usage: from=... to=... copy_func
|
424 |
|
|
# $to must not exist. to get around the no-clobber restriction, use `unset -f`.
|
425 |
|
|
{
|
426 |
|
|
: "${from:?}" "${to:?}"
|
427 |
|
|
func_exists "$from" || die "function does not exist: $from"
|
428 |
|
|
! func_exists "$to" || die "function already exists: $to"
|
429 |
|
|
local from_def="$(declare -f "$from")"
|
430 |
|
|
eval "$to${from_def#$from}"
|
431 |
|
|
}
|
432 |
|
|
|
433 |
|
|
func_override() # usage: func_override old_name__suffix
|
434 |
9559
|
aaronmk
|
{ from="${1%__*}" to="$1" copy_func; }
|
435 |
9233
|
aaronmk
|
|
436 |
|
|
ensure_nested_func() # usage: func__nested_func() { ensure_nested_func; ... }
|
437 |
|
|
{
|
438 |
|
|
local nested_func="${FUNCNAME[1]}"
|
439 |
|
|
local func="${nested_func%%__*}"
|
440 |
|
|
contains "$func" "${FUNCNAME[@]}" || \
|
441 |
|
|
die "$nested_func() must be used by $func()"
|
442 |
|
|
}
|
443 |
|
|
|
444 |
|
|
|
445 |
9240
|
aaronmk
|
#### paths
|
446 |
|
|
|
447 |
9313
|
aaronmk
|
# cache realpath
|
448 |
|
|
: "${realpath_cache=}" # default off because slower than without
|
449 |
|
|
if test "$realpath_cache"; then
|
450 |
|
|
func_override realpath__no_cache
|
451 |
|
|
realpath() # caches the last result for efficiency
|
452 |
|
|
{
|
453 |
|
|
local cache_key="$*"; load_cache
|
454 |
9331
|
aaronmk
|
if ! cached; then save_cache "$(realpath__no_cache "$@")" || return; fi
|
455 |
9313
|
aaronmk
|
echo_cached_value
|
456 |
|
|
}
|
457 |
|
|
fi
|
458 |
|
|
|
459 |
9244
|
aaronmk
|
rel_path() # usage: base_dir=... path=... rel_path
|
460 |
9240
|
aaronmk
|
{
|
461 |
9788
|
aaronmk
|
kw_params base_dir path
|
462 |
9244
|
aaronmk
|
: "${base_dir:?}" "${path:?}"
|
463 |
|
|
|
464 |
9246
|
aaronmk
|
local path="$path/" # add *extra* / to match path when exactly = base_dir
|
465 |
|
|
path="${path#$base_dir/}" # remove prefix shared with base_dir
|
466 |
|
|
path="${path%/}" # remove any remaining extra trailing /
|
467 |
9244
|
aaronmk
|
|
468 |
9245
|
aaronmk
|
if test ! "$path"; then path=.; fi # ensure non-empty
|
469 |
|
|
|
470 |
9244
|
aaronmk
|
echo_vars path
|
471 |
9240
|
aaronmk
|
echo "$path"
|
472 |
|
|
}
|
473 |
|
|
|
474 |
9309
|
aaronmk
|
cd -P . # expand symlinks in $PWD so it matches the output of realpath
|
475 |
|
|
# do before setting $top_script_abs so realpath has less symlinks to resolve
|
476 |
|
|
|
477 |
9791
|
aaronmk
|
canon_rel_path() # usage: [base_dir=...] canon_rel_path path
|
478 |
9331
|
aaronmk
|
{
|
479 |
9791
|
aaronmk
|
kw_params base_dir; local base_dir="${base_dir-$PWD}"
|
480 |
|
|
base_dir="$(realpath "$base_dir")" || return
|
481 |
9331
|
aaronmk
|
local path; path="$(realpath "$1")" || return
|
482 |
9791
|
aaronmk
|
rel_path
|
483 |
9331
|
aaronmk
|
}
|
484 |
9244
|
aaronmk
|
|
485 |
10143
|
aaronmk
|
canon_dir_rel_path() # usage: [base_dir=...] canon_dir_rel_path path
|
486 |
|
|
# if the path is a symlink, just its parent dir will be canonicalized
|
487 |
|
|
{
|
488 |
|
|
kw_params base_dir; local base_dir="${base_dir-$PWD}"
|
489 |
|
|
base_dir="$(realpath "$base_dir")" || return
|
490 |
|
|
local path; path="$(realpath "$(dirname "$1")")/$(basename "$1")" || return
|
491 |
|
|
rel_path
|
492 |
|
|
}
|
493 |
|
|
|
494 |
9240
|
aaronmk
|
# makes $1 a canon_rel_path if it's a filesystem path
|
495 |
|
|
alias cmd2rel_path="$(cat <<'EOF'
|
496 |
|
|
if test "$(type -t "$1")" = file && test -e "$1"; then # not relative to PATH
|
497 |
|
|
declare _1="$1"; shift
|
498 |
9788
|
aaronmk
|
_1="$(clog++ canon_rel_path "$_1")" || return
|
499 |
9331
|
aaronmk
|
set -- "$_1" "$@"
|
500 |
9240
|
aaronmk
|
fi
|
501 |
|
|
EOF
|
502 |
|
|
)"
|
503 |
|
|
|
504 |
9810
|
aaronmk
|
# usage: path_parents path; use ${dirs[@]} # includes the path itself
|
505 |
|
|
function path_parents()
|
506 |
|
|
{
|
507 |
|
|
echo_func; local path="$1" prev_path=; dirs=()
|
508 |
|
|
while test "$path" != "$prev_path"; do
|
509 |
|
|
prev_path="$path"
|
510 |
|
|
dirs+=("$path")
|
511 |
|
|
path="${path%/*}"
|
512 |
|
|
done
|
513 |
|
|
}
|
514 |
|
|
alias path_parents='declare dirs; "path_parents"'
|
515 |
9240
|
aaronmk
|
|
516 |
9810
|
aaronmk
|
|
517 |
9240
|
aaronmk
|
#### verbose output
|
518 |
|
|
|
519 |
|
|
|
520 |
9165
|
aaronmk
|
### command echoing
|
521 |
|
|
|
522 |
|
|
alias echo_params='log "$*"'
|
523 |
|
|
|
524 |
8995
|
aaronmk
|
fi # load new aliases
|
525 |
|
|
if self_being_included; then
|
526 |
|
|
|
527 |
9197
|
aaronmk
|
echo_cmd() { echo_params; }
|
528 |
9056
|
aaronmk
|
|
529 |
9549
|
aaronmk
|
function echo_run() { echo_params; "$@"; }
|
530 |
9796
|
aaronmk
|
# see echo_run alias after stub
|
531 |
9539
|
aaronmk
|
|
532 |
10044
|
aaronmk
|
echo_builtin() { echo_run builtin "$@"; } # usage: echo_builtin builtin_cmd...
|
533 |
|
|
|
534 |
9278
|
aaronmk
|
echo_eval() { echo_params; builtin eval "$@"; }
|
535 |
|
|
|
536 |
9730
|
aaronmk
|
# usage: redirs=(...); [cmd_name_log_inc=#] echo_redirs_cmd
|
537 |
9655
|
aaronmk
|
function echo_redirs_cmd()
|
538 |
|
|
{
|
539 |
9730
|
aaronmk
|
local cmd_name_log_inc="${cmd_name_log_inc-0}"
|
540 |
|
|
|
541 |
9657
|
aaronmk
|
# print <>file redirs before cmd, because they introduce it
|
542 |
9730
|
aaronmk
|
"log+" "$cmd_name_log_inc" echo_cmd "$@" $(
|
543 |
9809
|
aaronmk
|
set -- "${redirs[@]}" # operate on ${redirs[@]}
|
544 |
9657
|
aaronmk
|
while test "$#" -gt 0 && starts_with '[<>][^&]' "$1"
|
545 |
|
|
do log "$1 \\"; shift; done # log() will run *before* echo_cmd itself
|
546 |
|
|
echo "$@"
|
547 |
9655
|
aaronmk
|
)
|
548 |
|
|
}
|
549 |
|
|
alias echo_redirs_cmd='"echo_redirs_cmd" "$@"'
|
550 |
|
|
|
551 |
9263
|
aaronmk
|
## vars
|
552 |
|
|
|
553 |
|
|
echo_vars() # usage: echo_vars var...
|
554 |
|
|
{
|
555 |
9320
|
aaronmk
|
log+ 2
|
556 |
9263
|
aaronmk
|
if can_log; then
|
557 |
|
|
local var
|
558 |
|
|
for var in "${@%%=*}"; do
|
559 |
|
|
if isset "$var"; then log "$(declare -p "$var")"; fi
|
560 |
|
|
done
|
561 |
|
|
fi
|
562 |
|
|
}
|
563 |
|
|
|
564 |
|
|
echo_export() { builtin export "$@"; echo_vars "$@"; }
|
565 |
|
|
|
566 |
9379
|
aaronmk
|
alias export="echo_export" # automatically echo env vars when they are set
|
567 |
9263
|
aaronmk
|
|
568 |
|
|
func_override kw_params__lang
|
569 |
|
|
kw_params() { kw_params__lang "$@"; echo_vars "$@"; } # echo all keyword params
|
570 |
|
|
|
571 |
9273
|
aaronmk
|
## functions
|
572 |
9264
|
aaronmk
|
|
573 |
9315
|
aaronmk
|
# usage: local func=...; set_func_loc; use $file, $line
|
574 |
|
|
alias set_func_loc="$(cat <<'EOF'
|
575 |
|
|
: "${func:?}"
|
576 |
|
|
local func_info="$(shopt -s extdebug; declare -F "$func")" # 'func line file'
|
577 |
|
|
func_info="${func_info#$func }"
|
578 |
|
|
local line="${func_info%% *}"
|
579 |
|
|
local file="${func_info#$line }"
|
580 |
|
|
EOF
|
581 |
|
|
)"
|
582 |
|
|
|
583 |
|
|
fi # load new aliases
|
584 |
|
|
if self_being_included; then
|
585 |
|
|
|
586 |
|
|
func_loc() # gets where function declared in the format file:line
|
587 |
9331
|
aaronmk
|
{
|
588 |
|
|
local func="$1"; set_func_loc
|
589 |
|
|
file="$(canon_rel_path "$file")" || return
|
590 |
|
|
echo "$file:$line"
|
591 |
|
|
}
|
592 |
9315
|
aaronmk
|
|
593 |
9273
|
aaronmk
|
# usage: func() { [minor=1] echo_func; ... }
|
594 |
9317
|
aaronmk
|
function echo_func()
|
595 |
9871
|
aaronmk
|
# usage: "echo_func" "$FUNCNAME" "$@" && indent || true
|
596 |
9273
|
aaronmk
|
# exit status: whether function call was echoed
|
597 |
|
|
{
|
598 |
9872
|
aaronmk
|
log++; can_log || return
|
599 |
9317
|
aaronmk
|
local func="$1"; shift
|
600 |
9788
|
aaronmk
|
local loc; loc="$(clog++ func_loc "$func")" || return
|
601 |
9331
|
aaronmk
|
echo_cmd "$loc" "$func" "$@"
|
602 |
9273
|
aaronmk
|
}
|
603 |
9790
|
aaronmk
|
# see echo_func alias after stub
|
604 |
9273
|
aaronmk
|
|
605 |
9276
|
aaronmk
|
fi # load new aliases
|
606 |
|
|
if self_being_included; then
|
607 |
9273
|
aaronmk
|
|
608 |
9276
|
aaronmk
|
|
609 |
9279
|
aaronmk
|
#### streams
|
610 |
|
|
|
611 |
|
|
fd_exists() { (: <&"$1") 2>/dev/null; }
|
612 |
|
|
|
613 |
|
|
require_fd_not_exists() # usage: require_fd_not_exists fd || return 0
|
614 |
|
|
{ ! fd_exists "$1" || type=info die "fd $1 already exists, skipping"; }
|
615 |
|
|
|
616 |
9712
|
aaronmk
|
set_fds() # usage: set_fds redirect...
|
617 |
|
|
{
|
618 |
|
|
echo_func
|
619 |
|
|
|
620 |
|
|
# add #<>&- before every #<>&# reopen to fix strange bash bug
|
621 |
9804
|
aaronmk
|
local redirs=() i
|
622 |
9712
|
aaronmk
|
for i in "$@"; do
|
623 |
9713
|
aaronmk
|
local redir_prefix="$(match_prefix '*[<>]' "$i")"
|
624 |
9712
|
aaronmk
|
if test "$redir_prefix"; then redirs+=("$redir_prefix&-"); fi
|
625 |
9713
|
aaronmk
|
redirs+=("$i")
|
626 |
9712
|
aaronmk
|
done
|
627 |
|
|
set -- "${redirs[@]}"
|
628 |
|
|
|
629 |
9795
|
aaronmk
|
if (($# > 0)); then echo_eval exec "$@"; fi
|
630 |
9712
|
aaronmk
|
}
|
631 |
9279
|
aaronmk
|
|
632 |
|
|
fd_set_default() # usage: fd_set_default 'dest[<>]src'
|
633 |
|
|
{
|
634 |
|
|
echo_func
|
635 |
|
|
local dest="${1%%[<>]*}"
|
636 |
|
|
require_fd_not_exists "$dest" || return 0
|
637 |
|
|
set_fds "$1"
|
638 |
|
|
}
|
639 |
|
|
|
640 |
9728
|
aaronmk
|
function filter_fd() # usage: (fd=# filter_fd filter_cmd...; with filter...)
|
641 |
9717
|
aaronmk
|
# useful e.g. to filter logging output or highlight errors
|
642 |
|
|
{
|
643 |
|
|
echo_func; kw_params fd; : "${fd?}"
|
644 |
|
|
set_fds "$fd>" >(pipe_delay; redirs=(">&$fd" "${redirs[@]}"); redir "$@")
|
645 |
|
|
pipe_delay; pipe_delay # wait for >()'s pipe_delay and initial logging
|
646 |
|
|
}
|
647 |
9728
|
aaronmk
|
alias filter_fd='"filter_fd" ' # last space alias-expands next word
|
648 |
9717
|
aaronmk
|
|
649 |
9651
|
aaronmk
|
# convention: use fd 40/41/42 for command-specific alternate stdin/stdout/stderr
|
650 |
9900
|
aaronmk
|
# mnemonic: 4 looks like A for Alternate
|
651 |
9651
|
aaronmk
|
# do NOT use 1x, which are used by eval (which is used by set_fds())
|
652 |
|
|
# do NOT use 2x, which are used as global stdin/stdout/stderr
|
653 |
|
|
# do NOT use 3x, which are used for logging
|
654 |
9279
|
aaronmk
|
|
655 |
9282
|
aaronmk
|
setup_log_fd() # view logging output at verbosity >= 5
|
656 |
|
|
{
|
657 |
9319
|
aaronmk
|
log+ 4; log-- echo_func
|
658 |
9282
|
aaronmk
|
fd_set_default '30>&2' || true # stdlog
|
659 |
|
|
log_fd=30 # stdlog
|
660 |
|
|
}
|
661 |
|
|
setup_log_fd
|
662 |
|
|
|
663 |
9279
|
aaronmk
|
set_global_fds()
|
664 |
|
|
# allows commands to access global stdin/stdout/stderr using fd 20/21/22
|
665 |
|
|
# this works even when /dev/tty isn't available
|
666 |
9283
|
aaronmk
|
# view logging output at verbosity >= 3
|
667 |
9279
|
aaronmk
|
{
|
668 |
9319
|
aaronmk
|
log+ 2; log-- echo_func
|
669 |
9279
|
aaronmk
|
# ignore errors if a source fd isn't open
|
670 |
|
|
fd_set_default '20<&0' || true
|
671 |
|
|
fd_set_default '21>&1' || true
|
672 |
|
|
fd_set_default '22>&2' || true
|
673 |
|
|
}
|
674 |
|
|
set_global_fds
|
675 |
|
|
|
676 |
|
|
# usage: explicit_errors_only=1 script...
|
677 |
|
|
# show only explicitly-displayed errors (which have been redirected to fd 22)
|
678 |
|
|
# most of the time this has the same effect as `verbosity=0 script...`,
|
679 |
|
|
# which displays everything that isn't explicitly hidden
|
680 |
|
|
# this option should only be used for testing the explicit error displaying
|
681 |
|
|
if test "$explicit_errors_only"; then disable_logging; fi
|
682 |
|
|
|
683 |
|
|
|
684 |
9731
|
aaronmk
|
echo_vars is_outermost
|
685 |
|
|
|
686 |
|
|
|
687 |
9264
|
aaronmk
|
#### paths
|
688 |
|
|
|
689 |
9735
|
aaronmk
|
top_symlink_dir="$(dirname "$0")"; echo_vars top_symlink_dir
|
690 |
9736
|
aaronmk
|
top_symlink_dir_abs="$(realpath "$top_symlink_dir")"
|
691 |
|
|
echo_vars top_symlink_dir_abs
|
692 |
9724
|
aaronmk
|
|
693 |
9269
|
aaronmk
|
top_script_abs="$(realpath "$0")"; echo_vars top_script_abs # outermost script
|
694 |
|
|
# realpath this before doing any cd so this points to the right place
|
695 |
9724
|
aaronmk
|
top_dir_abs="$(dirname "$top_script_abs")"; echo_vars top_dir_abs
|
696 |
9269
|
aaronmk
|
|
697 |
9265
|
aaronmk
|
set_paths()
|
698 |
|
|
{
|
699 |
9788
|
aaronmk
|
top_script="$(clog++ canon_rel_path "$top_script_abs")" || return
|
700 |
9331
|
aaronmk
|
echo_vars top_script
|
701 |
|
|
top_dir="$(dirname "$top_script")" || return; echo_vars top_dir
|
702 |
9265
|
aaronmk
|
}
|
703 |
|
|
set_paths
|
704 |
9264
|
aaronmk
|
|
705 |
9945
|
aaronmk
|
# usage: in_top_dir cmd...
|
706 |
|
|
function in_top_dir() { echo_func; (cd "$top_dir"; "$@"); }
|
707 |
|
|
alias in_top_dir='"in_top_dir" ' # last space alias-expands next word
|
708 |
|
|
|
709 |
9725
|
aaronmk
|
PATH_rm() # usage: PATH_rm path... # removes components from the PATH
|
710 |
|
|
{
|
711 |
|
|
echo_func; echo_vars PATH; : "${PATH?}"
|
712 |
10020
|
aaronmk
|
log+ 2
|
713 |
|
|
split : "$PATH"
|
714 |
|
|
local new_paths=()
|
715 |
|
|
for path in "${parts[@]}"; do
|
716 |
|
|
if ! contains "$path" "$@"; then new_paths+=("$path"); fi
|
717 |
|
|
done
|
718 |
|
|
PATH="$(delim=: join "${new_paths[@]}")" || return
|
719 |
10154
|
aaronmk
|
log- 2
|
720 |
9725
|
aaronmk
|
echo_vars PATH
|
721 |
|
|
}
|
722 |
9264
|
aaronmk
|
|
723 |
9726
|
aaronmk
|
no_PATH_recursion() # usage: (no_PATH_recursion; cmd...)
|
724 |
|
|
# allows running a system command of the same name as the script
|
725 |
9737
|
aaronmk
|
{
|
726 |
|
|
echo_func
|
727 |
|
|
PATH_rm "$top_dir_abs" "$top_symlink_dir" "$top_symlink_dir_abs" "$top_dir"
|
728 |
|
|
}
|
729 |
9725
|
aaronmk
|
|
730 |
10021
|
aaronmk
|
# makes command in $1 nonrecursive
|
731 |
|
|
# allows running a system command of the same name as the script
|
732 |
|
|
alias cmd2abs_path="$(cat <<'EOF'
|
733 |
|
|
declare _1="$1"; shift
|
734 |
|
|
_1="$(indent; no_PATH_recursion; log++; which "$_1"|echo_stdout)" || return
|
735 |
|
|
set -- "$_1" "$@"
|
736 |
|
|
EOF
|
737 |
|
|
)"
|
738 |
9726
|
aaronmk
|
|
739 |
10021
|
aaronmk
|
|
740 |
9264
|
aaronmk
|
#### verbose output
|
741 |
|
|
|
742 |
|
|
|
743 |
9123
|
aaronmk
|
## internal commands
|
744 |
|
|
|
745 |
9166
|
aaronmk
|
.()
|
746 |
|
|
{
|
747 |
9850
|
aaronmk
|
clog++ clog++ echo_func
|
748 |
|
|
cmd2rel_path; set -- "$FUNCNAME" "$@"
|
749 |
9435
|
aaronmk
|
if (log++; echo_params; can_log); then indent; fi
|
750 |
9166
|
aaronmk
|
builtin "$@"
|
751 |
|
|
}
|
752 |
9158
|
aaronmk
|
|
753 |
9853
|
aaronmk
|
.rel() # usage: .rel file [args...] # file relative to ${BASH_SOURCE[0]} dir
|
754 |
|
|
{
|
755 |
|
|
clog++ clog++ echo_func; local file="$1"; shift
|
756 |
10059
|
aaronmk
|
. "$(canon_rel_path "$(dirname "$(realpath "${BASH_SOURCE[1]}")")/$file")" \
|
757 |
|
|
"$@"
|
758 |
9853
|
aaronmk
|
}
|
759 |
|
|
|
760 |
9253
|
aaronmk
|
cd() # indent is permanent within subshell cd was used in
|
761 |
|
|
{
|
762 |
9393
|
aaronmk
|
log++ echo_func
|
763 |
9306
|
aaronmk
|
cmd2rel_path; echo_cmd "$FUNCNAME" "$@"
|
764 |
9435
|
aaronmk
|
if can_log; then caller_indent; fi
|
765 |
9307
|
aaronmk
|
# -P: expand symlinks so $PWD matches the output of realpath
|
766 |
9306
|
aaronmk
|
builtin "$FUNCNAME" -P "$@"
|
767 |
9313
|
aaronmk
|
|
768 |
|
|
func=realpath clear_cache
|
769 |
9266
|
aaronmk
|
set_paths
|
770 |
9253
|
aaronmk
|
}
|
771 |
|
|
|
772 |
9110
|
aaronmk
|
## external commands
|
773 |
|
|
|
774 |
9262
|
aaronmk
|
disable_logging() { set_fds "$log_fd>/dev/null"; }
|
775 |
9224
|
aaronmk
|
|
776 |
9685
|
aaronmk
|
function redir() # usage: local redirs=(#<>...); redir cmd...; unset redirs
|
777 |
9138
|
aaronmk
|
# to view only explicitly-displayed errors: explicit_errors_only=1 script...
|
778 |
9134
|
aaronmk
|
{
|
779 |
9686
|
aaronmk
|
echo_func; kw_params redirs
|
780 |
9687
|
aaronmk
|
|
781 |
|
|
case "$1" in redir|command) "$@"; return;; esac # redir will be run later
|
782 |
9685
|
aaronmk
|
(
|
783 |
|
|
log++ set_fds "${redirs[@]}"
|
784 |
|
|
(case "$1" in command__exec) shift;; esac; echo_redirs_cmd)
|
785 |
|
|
"$@"
|
786 |
|
|
) || return
|
787 |
|
|
}
|
788 |
|
|
alias redir='"redir" ' # last space alias-expands next word
|
789 |
|
|
|
790 |
9689
|
aaronmk
|
alias_append save_e '; unset redirs' # don't redirect error handlers
|
791 |
|
|
|
792 |
10022
|
aaronmk
|
fi # load new aliases
|
793 |
|
|
if self_being_included; then
|
794 |
|
|
|
795 |
|
|
command() # usage: [cmd_log_fd=|1|2|#] [verbosity_min=] [nonrecursive=1] \
|
796 |
|
|
# command extern_cmd...
|
797 |
9685
|
aaronmk
|
{
|
798 |
9740
|
aaronmk
|
echo_func; kw_params log_fd cmd_log_fd redirs verbosity_min
|
799 |
9291
|
aaronmk
|
# if no cmd_log_fd, limit log_fd in case command uses util.sh
|
800 |
|
|
local cmd_log_fd="${cmd_log_fd-$log_fd}"
|
801 |
9473
|
aaronmk
|
local redirs=("${redirs[@]}")
|
802 |
9231
|
aaronmk
|
|
803 |
9685
|
aaronmk
|
# determine redirections
|
804 |
9436
|
aaronmk
|
if test "$cmd_log_fd"; then
|
805 |
|
|
if can_log; then
|
806 |
|
|
if test "$cmd_log_fd" != "$log_fd"; then
|
807 |
9473
|
aaronmk
|
redirs+=("$cmd_log_fd>&$log_fd")
|
808 |
9436
|
aaronmk
|
fi # else no redir needed
|
809 |
9473
|
aaronmk
|
else redirs+=("$cmd_log_fd>/dev/null");
|
810 |
9436
|
aaronmk
|
fi
|
811 |
|
|
fi
|
812 |
9444
|
aaronmk
|
|
813 |
10022
|
aaronmk
|
if test "$nonrecursive"; then cmd2abs_path; else cmd2rel_path; fi
|
814 |
9685
|
aaronmk
|
redir command__exec "$@" || die_e
|
815 |
9134
|
aaronmk
|
}
|
816 |
9685
|
aaronmk
|
command__exec()
|
817 |
|
|
{
|
818 |
|
|
ensure_nested_func
|
819 |
|
|
if can_log; then indent; fi
|
820 |
|
|
if test "$verbosity_min"; then verbosity_min "$verbosity_min"; fi
|
821 |
9868
|
aaronmk
|
verbosity_compat
|
822 |
9723
|
aaronmk
|
builtin command "$@"
|
823 |
9685
|
aaronmk
|
}
|
824 |
9133
|
aaronmk
|
|
825 |
9110
|
aaronmk
|
|
826 |
|
|
### external command input/output
|
827 |
8907
|
aaronmk
|
|
828 |
9074
|
aaronmk
|
echo_stdin() # usage: input|echo_stdin|cmd
|
829 |
8702
|
aaronmk
|
{
|
830 |
8897
|
aaronmk
|
if can_log; then
|
831 |
8998
|
aaronmk
|
pipe_delay
|
832 |
9212
|
aaronmk
|
echo ----- >&"$log_fd"
|
833 |
|
|
tee -a /dev/fd/"$log_fd";
|
834 |
|
|
echo ----- >&"$log_fd"
|
835 |
8897
|
aaronmk
|
else cat
|
836 |
|
|
fi
|
837 |
8702
|
aaronmk
|
}
|
838 |
8275
|
aaronmk
|
|
839 |
9318
|
aaronmk
|
echo_stdout() { echo_stdin; } # usage: cmd|echo_stdout
|
840 |
9044
|
aaronmk
|
|
841 |
8873
|
aaronmk
|
|
842 |
8854
|
aaronmk
|
#### commands
|
843 |
|
|
|
844 |
9622
|
aaronmk
|
already_exists_msg() # usage: cond || what=... already_exists_msg || return 0
|
845 |
|
|
{ type=info die "$what already exists, skipping"; }
|
846 |
9620
|
aaronmk
|
|
847 |
9122
|
aaronmk
|
require_not_exists() # usage: require_not_exists file || return 0
|
848 |
9622
|
aaronmk
|
{ test ! -e "$1" || what="file \"$1\"" already_exists_msg; }
|
849 |
9062
|
aaronmk
|
|
850 |
9680
|
aaronmk
|
function to_file() # usage: stdout=... [if_not_exists=1] [del=] to_file cmd...
|
851 |
8986
|
aaronmk
|
# auto-removes a command's output file on error (like make's .DELETE_ON_ERROR)
|
852 |
9048
|
aaronmk
|
{
|
853 |
9695
|
aaronmk
|
echo_func; kw_params stdout if_not_exists del
|
854 |
9680
|
aaronmk
|
: "${stdout?}"; local del="${del-1}"
|
855 |
9475
|
aaronmk
|
if test "$if_not_exists"; then require_not_exists "$stdout" || return 0; fi
|
856 |
9481
|
aaronmk
|
|
857 |
9652
|
aaronmk
|
local redirs=("${redirs[@]}" ">$stdout")
|
858 |
9690
|
aaronmk
|
redir "$@" || { save_e; test ! "$del" || rm "$stdout"; rethrow; }
|
859 |
9048
|
aaronmk
|
}
|
860 |
9177
|
aaronmk
|
alias to_file='"to_file" ' # last space alias-expands next word
|
861 |
8986
|
aaronmk
|
|
862 |
9747
|
aaronmk
|
log_bg() { symbol='&' log_custom "$@"; }
|
863 |
|
|
|
864 |
|
|
log_last_bg() { log_bg '$!='"$!"; }
|
865 |
|
|
|
866 |
|
|
function bg_cmd() { echo_func; "$@" & log_last_bg; } # usage: bg_cmd cmd...
|
867 |
|
|
alias bg_cmd='"bg_cmd" ' # last space alias-expands next word
|
868 |
|
|
|
869 |
8272
|
aaronmk
|
|
870 |
9552
|
aaronmk
|
#### filesystem
|
871 |
|
|
|
872 |
9830
|
aaronmk
|
alias mkdir='mkdir -p'
|
873 |
|
|
|
874 |
9556
|
aaronmk
|
alias file_size=\
|
875 |
9558
|
aaronmk
|
"stat `case "$(uname)" in Darwin) echo -f %z;; *) echo --format=%s;; esac`"
|
876 |
9552
|
aaronmk
|
|
877 |
9829
|
aaronmk
|
alias wildcard='shopt -s nullglob; echo' # usage: "$(wildcard glob...)"
|
878 |
9939
|
aaronmk
|
alias wildcard1='shopt -s nullglob; echo1' # usage: "$(wildcard1 glob...)"
|
879 |
9552
|
aaronmk
|
|
880 |
9831
|
aaronmk
|
fi # load new aliases
|
881 |
|
|
if self_being_included; then
|
882 |
9829
|
aaronmk
|
|
883 |
9831
|
aaronmk
|
mv2dir() { echo_func; mkdir "${!#}"; mv "$@"; } # usage: mv2dir ... dir
|
884 |
|
|
|
885 |
|
|
# usage: (mv_glob ... dir)
|
886 |
|
|
function mv_glob() { echo_func; if (($# > 1)); then mv2dir "$@"; fi; }
|
887 |
|
|
alias mv_glob='shopt -s nullglob; "mv_glob"'
|
888 |
|
|
|
889 |
|
|
|
890 |
8966
|
aaronmk
|
#### URLs
|
891 |
|
|
|
892 |
9074
|
aaronmk
|
localize_url() { test _"$1" = _"$(hostname -f)" || echo "$1"; }
|
893 |
8966
|
aaronmk
|
|
894 |
8704
|
aaronmk
|
fi
|