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
func_override () # usage: func_override old_name__suffix
94
{ from="${1%%__*}" to="$1" copy_func; }
95

    
96

    
97
#### integers
98

    
99
let! () { let "$@" || true; } # always returns true; safe to use for setting
100
	# "If the last ARG evaluates to 0, let returns 1" (`help let`)
101

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

    
104

    
105
#### arrays
106

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

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

    
115

    
116
#### paths
117

    
118
canon_rel_path ()
119
{
120
	local path="$1"
121
	path="$(realpath "$path")" # canonicalize
122
	path="${path#$(pwd -P)/}" # remove any shared prefix with the current dir
123
	echo "$path"
124
}
125

    
126

    
127
#### verbose output
128

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

    
133
# set verbosity
134
if isset verbose; then : "${verbosity:=$(bool2int "$verbose")}"; fi
135
: "${verbosity=3}" # default
136
: "${verbosity:=0}" # ensure non-empty
137
declare -i verbosity # ensure integer
138
export verbosity # propagate the verbosity to invoked commands
139

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

    
142
: "${log_indent=  }"
143

    
144
# usage: in func:      inc_log_level; ...
145
#        outside func: inc_log_level; ...; dec_log_level
146
alias inc_log_level='declare verbosity="$verbosity" PS4="$log_indent$PS4"
147
let! verbosity--'
148
alias dec_log_level='declare verbosity="$verbosity" PS4="${PS4#$log_indent}"
149
let! verbosity++'
150

    
151
fi # load new aliases
152
if self_being_included; then
153

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

    
158
limit_stderr_cmd () # usage: [stdout2stderr=1] limit_stderr_cmd cmd...
159
{
160
	case "$1" in echo_run) shift; echo_cmd "$@";; esac
161
	(limit_stderr
162
		if test -n "$stdout2stderr"; then stdout2stderr; fi
163
		"$@"
164
	) || return
165
}
166
alias limit_stderr_cmd='limit_stderr_cmd ' # last space alias-expands next word
167

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

    
170
echo_run () { echo_cmd "$@"; "$@"; }
171

    
172
# auto-echo common external commands
173
for cmd in rm; do alias "$cmd=echo_run $cmd"; done; unset cmd
174

    
175
# echo all external commands
176
alias extern="echo_run extern " # last space alias-expands next word
177

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

    
180
# commands that are always external
181
for cmd in env; do alias "$cmd=extern $cmd"; done; unset cmd
182

    
183
function echo_func ()
184
{
185
	inc_log_level
186
	local script="$(canon_rel_path "${BASH_SOURCE[1]}")"
187
	echo_cmd "$script:${BASH_LINENO[0]}" "${FUNCNAME[1]}" "$@"
188
}
189

    
190
# usage: cmd1 | { pipe_delay; cmd2; }
191
alias pipe_delay='sleep 0.1' # s; display after leading output of cmd1
192

    
193
fi # load new aliases
194
if self_being_included; then
195

    
196
echo_stdin () # usage: input|echo_stdin|cmd
197
{
198
	inc_log_level
199
	if can_log; then
200
		pipe_delay
201
		echo ----- >&2
202
		tee -a /dev/stderr;
203
		echo ----- >&2
204
	else cat
205
	fi
206
}
207

    
208
alias echo_stdout='echo_stdin' # usage: cmd|echo_stdout
209

    
210
echo_vars () # usage: echo_vars var...
211
{
212
	inc_log_level; inc_log_level
213
	if can_log; then
214
		local var
215
		for var in "${@%%=*}"; do { echo -n "$PS4"; declare -p "$var";} >&2;done
216
	fi
217
}
218

    
219
echo_export () { builtin export "$@"; echo_vars "$@"; }
220

    
221
if test "$verbosity" -ge 2; then
222
	alias export="echo_export" # automatically echo env vars when they are set
223
fi
224

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

    
227
fi # load new aliases
228
if self_being_included; then
229

    
230

    
231
#### strings
232

    
233
sed_ere_flag="$(test "$(uname)" = Darwin && echo E || echo r)"
234

    
235
sed () { self -"$sed_ere_flag" "$@";}
236

    
237

    
238
#### vars
239

    
240
set_var () { eval "$1"'="$2"'; }
241

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

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

    
247
# usage: local prefix=..._; import_vars
248
alias import_vars="$(cat <<'EOF'
249
: "${prefix:?}"
250
local src_var dest_var
251
for src_var in $(eval echo '${!'$prefix'*}'); do
252
	dest_var="${src_var#$prefix}"
253
	local "$dest_var=${!src_var}"; echo_vars "$dest_var"
254
done
255
EOF
256
)"
257

    
258

    
259
#### commands
260

    
261
top_script="$0" # outermost script
262
top_dir="$(dirname "$top_script")"
263

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

    
269
run_args_cmd () # runs the command line args command
270
{
271
	test $? -eq 0 || return
272
	eval set -- "$(reverse "${BASH_ARGV[@]}")"
273
	test $# -ge 1 || set -- all
274
	echo_cmd "$(canon_rel_path "$0")" "$@"; "$@"
275
}
276

    
277
fwd () # usage: subdirs=(...); fwd "$FUNCNAME" "$@"
278
{
279
	echo_func
280
	: "${subdirs?}"
281
	
282
	for subdir in "${subdirs[@]}"; do
283
		"$(dirname "${BASH_SOURCE[1]}")"/"$subdir"/run "$@"
284
	done
285
}
286

    
287

    
288
#### URLs
289

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

    
292
fi
(5-5/5)