Project

General

Profile

1
#!/bin/bash -e
2
set -o errexit # in case caller did not have -e in #! line
3

    
4
if test ! "$_util_sh_include_guard_utils"; then
5
_util_sh_include_guard_utils=1
6

    
7
function extern () { (exec "$@") || return; }
8

    
9
isset () { test -n "${!1+isset}"; }
10

    
11
realpath () { readlink -f -- "$1"; }
12

    
13
include_guard_var () { realpath "$1"|"extern" sed 's/[^a-zA-Z0-9_]/_/g'; }
14

    
15
self_not_included () # usage: if self_not_included; then ... fi
16
{
17
	test $# -ge 1 || set -- "${BASH_SOURCE[1]}"
18
	local include_guard="$(include_guard_var "$1")"
19
	alias self_being_included=false
20
	! isset "$include_guard" && \
21
	{ eval "$include_guard"=1; alias self_being_included=true; }
22
}
23

    
24
# 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
fi
31

    
32

    
33
if self_not_included "${BASH_SOURCE[0]}"; then
34

    
35

    
36
#### options
37

    
38
shopt -s expand_aliases
39

    
40

    
41
#### aliases
42

    
43
unalias () { builtin unalias "$@" 2>&- || true; } # no error if undefined
44

    
45

    
46
#### exceptions
47

    
48
# usage: cmd || { save_e; ...; rethrow; }
49
alias export_e='e=$?'
50
alias save_e='declare e=$?'
51
alias rethrow='return "$e"'
52
alias rethrow_subshell='exit "$e"'
53

    
54
fi # load new aliases
55
if self_being_included; then
56

    
57
# usage: cmd || die msg
58
die () { save_e; echo "$1" >&2; rethrow; }
59

    
60
# usage: cmd || { save_e; log_e; ...; rethrow; }
61
log_e () { echo "! command exited with error $e" >&2; }
62

    
63
# usage: try cmd...; ignore status; if catch status; then ...; fi; end_try
64

    
65
function try () { e=0; "$@" || { export_e; true; }; }
66
alias try='declare e; try ' # last space alias-expands next word
67

    
68
catch () { test "$e" -eq "$1"; e=0; }
69

    
70
ignore () { catch "$@" || true; }
71

    
72
alias end_try='rethrow'
73
alias end_try_subshell='rethrow_subshell'
74

    
75
fi # load new aliases
76
if self_being_included; then
77

    
78

    
79
#### functions
80

    
81
func_exists () { declare -f "$1" >/dev/null; }
82

    
83
copy_func () # usage: from=... to=... copy_func
84
# $to must not exist. to get around the no-clobber restriction, use `unset -f`.
85
{
86
	: "${from:?}" "${to:?}"
87
	func_exists "$from" || die "function does not exist: $from"
88
	! func_exists "$to" || die "function already exists: $to"
89
	local from_def="$(declare -f "$from")"
90
	eval "$to${from_def#$from}"
91
}
92

    
93

    
94
#### integers
95

    
96
let () { builtin let "$@" || true; }
97
	# "If the last ARG evaluates to 0, let returns 1" (`help let`)
98

    
99
bool2int () { try test -z "$1"; echo "$e"; } # empty->0; non-empty->1
100

    
101

    
102
#### arrays
103

    
104
join () { local IFS="$delim"; echo "$*"; } # usage: delim=... join elems...
105

    
106
reverse () # usage: array=($(reverse args...))
107
{
108
	local i
109
	for (( i=$#; i >= 1; i-- )); do printf '%q ' "${!i}"; done
110
}
111

    
112

    
113
#### verbose output
114

    
115
# usage: (stdout2stderr; cmd...) || return
116
# `|| return` needed on Mac because of bug where -e doesn't apply to ()
117
stdout2stderr () { exec >&2; }
118

    
119
# set verbosity
120
if isset verbose; then : "${verbosity:=$(bool2int "$verbose")}"; fi
121
: "${verbosity=3}" # default
122
: "${verbosity:=0}" # ensure non-empty
123
declare -i verbosity # ensure integer
124
export verbosity # propagate the verbosity to invoked commands
125

    
126
can_log () { test "$verbosity" -gt 0; } # verbosity=0 turns off all logging
127

    
128
: "${log_indent=  }"
129

    
130
# usage: in func:      inc_log_level; ...
131
#        outside func: inc_log_level; ...; dec_log_level
132
alias inc_log_level='declare verbosity="$verbosity" PS4="$log_indent$PS4"
133
let verbosity--'
134
alias dec_log_level='declare verbosity="$verbosity" PS4="${PS4#$log_indent}"
135
let verbosity++'
136

    
137
fi # load new aliases
138
if self_being_included; then
139

    
140
# usage: (limit_stderr; cmd...) || return
141
# `|| return` needed on Mac because of bug where -e doesn't apply to ()
142
limit_stderr () { inc_log_level; if ! can_log; then exec 2>/dev/null; fi; }
143

    
144
limit_stderr_cmd () # usage: [stdout2stderr=1] limit_stderr_cmd cmd...
145
{
146
	case "$1" in echo_run) shift; echo_cmd "$@";; esac
147
	(limit_stderr
148
		if test -n "$stdout2stderr"; then stdout2stderr; fi
149
		"$@"
150
	) || return
151
}
152
alias limit_stderr_cmd='limit_stderr_cmd ' # last space alias-expands next word
153

    
154
echo_cmd () { if can_log; then echo "$PS4$*" >&2; fi; }
155

    
156
echo_run () { echo_cmd "$@"; "$@"; }
157

    
158
# auto-echo common external commands
159
for cmd in rm; do alias "$cmd=echo_run $cmd"; done; unset cmd
160

    
161
# echo all external commands
162
alias extern="echo_run extern " # last space alias-expands next word
163

    
164
alias self='extern "$FUNCNAME"' # usage: wrapper () { self ...; }
165

    
166
# commands that are always external
167
for cmd in env; do alias "$cmd=extern $cmd"; done; unset cmd
168

    
169
canon_rel_path ()
170
{
171
	local path="$1"
172
	path="$(realpath "$path")" # canonicalize
173
	path="${path#$(pwd -P)/}" # remove any shared prefix with the current dir
174
	echo "$path"
175
}
176

    
177
function echo_func ()
178
{
179
	inc_log_level
180
	local script="$(canon_rel_path "${BASH_SOURCE[1]}")"
181
	echo_cmd "$script:${BASH_LINENO[0]}" "${FUNCNAME[1]}" "$@"
182
}
183

    
184
# usage: cmd1 | { pipe_delay; cmd2; }
185
alias pipe_delay='sleep 0.1' # s; display after leading output of cmd1
186

    
187
fi # load new aliases
188
if self_being_included; then
189

    
190
echo_stdin () # usage: input|echo_stdin|cmd
191
{
192
	inc_log_level
193
	if can_log; then
194
		pipe_delay
195
		echo ----- >&2
196
		tee -a /dev/stderr;
197
		echo ----- >&2
198
	else cat
199
	fi
200
}
201

    
202
echo_vars () # usage: echo_vars var...
203
{
204
	inc_log_level; inc_log_level
205
	if can_log; then
206
		local var
207
		for var in "${@%%=*}"; do { echo -n "$PS4"; declare -p "$var";} >&2;done
208
	fi
209
}
210

    
211
echo_export () { builtin export "$@"; echo_vars "$@"; }
212

    
213
if test "$verbosity" -ge 2; then
214
	alias export="echo_export" # automatically echo env vars when they are set
215
fi
216

    
217
usage () { echo "Usage: $1" >&2; (exit 2); }
218

    
219
fi # load new aliases
220
if self_being_included; then
221

    
222

    
223
#### strings
224

    
225
sed_ere_flag="$(test "$(uname)" = Darwin && echo E || echo r)"
226

    
227
sed () { self -"$sed_ere_flag" "$@";}
228

    
229

    
230
#### vars
231

    
232
set_var () { eval "$1"'="$2"'; }
233

    
234
set_inv () { set_var no_"$1" "$(test -n "${!1}" || echo 1)"; }
235

    
236
# usage: local var=...; local_inv
237
alias local_inv='declare "no_$var=$(test -n "${!var}" || echo 1)"'
238

    
239
# usage: local prefix=..._; import_vars
240
alias import_vars="$(cat <<'EOF'
241
: "${prefix:?}"
242
local src_var dest_var
243
for src_var in $(eval echo '${!'$prefix'*}'); do
244
	dest_var="${src_var#$prefix}"
245
	local "$dest_var=${!src_var}"; echo_vars "$dest_var"
246
done
247
EOF
248
)"
249

    
250

    
251
#### commands
252

    
253
top_script="$0" # outermost script
254
top_dir="$(dirname "$top_script")"
255

    
256
# auto-removes a command's output file on error (like make's .DELETE_ON_ERROR)
257
function to_file () # usage: stdout=... to_file cmd...
258
{ : "${stdout?}"; "$@" >"$stdout" || { save_e; log_e; rm "$stdout"; rethrow;}; }
259
alias to_file='to_file ' # last space alias-expands next word
260

    
261
run_args_cmd () # runs the command line args command
262
{
263
	test $? -eq 0 || return
264
	eval set -- "$(reverse "${BASH_ARGV[@]}")"
265
	test $# -ge 1 || set -- all
266
	echo_cmd "$(canon_rel_path "$0")" "$@"; "$@"
267
}
268

    
269
fwd () # usage: subdirs=(...); fwd "$FUNCNAME" "$@"
270
{
271
	echo_func
272
	: "${subdirs?}"
273
	
274
	for subdir in "${subdirs[@]}"; do
275
		"$(dirname "${BASH_SOURCE[1]}")"/"$subdir"/run "$@"
276
	done
277
}
278

    
279

    
280
#### URLs
281

    
282
localize_url () { test _"$1" = _"$(hostname -f)" || echo "$1"; }
283

    
284
fi
(5-5/5)