[code:1]#! /bin/sh
# bar
# 'cat' with ASCII progress bar
# (c) Henrik Theiling
BAR_VERSION=1.4
# Synopsis:
# 'bar' works just like 'cat', but shows a progress bar in ASCII art on stderr.
# The script's main function is meant to be usable in any Bourne shell to be
# suitable for install scripts without the need for any additional tool.
#
# Shell Script Usage: bar [options] [files]
# Options:
# -h displays help
# ...
#
# Examples:
# Normal pipe:
#
# : bar mypack.tar.bz2 | tar xjpf -
#
# Individual pipe for each file:
#
# : bar -c 'tar xjpf -' mypack1.tar.bz2 mypack2.tar.bz2
#
# Individual pipe, using ${bar_file} variable:
#
# : bar -c 'echo ${bar_file}: ; gzip -dc | tar tvf -' \
# : -e .tar.gz \
# : file1 file2 file3 file4 file5 \
# : > package-list.txt
#####################################################
# Programs and shell commands:
#
# Required (otherwise this fails):
#
# if, then, else, fi, expr, test, cat, eval, exec
# shell functions
#
# test:
# a = b
# a -lt b
# a -gt b
# a -le b
# -f a
# -n a
# -z a
#
# expr:
# a + b
# a - b
# a '*' b
# a / b
# a : b
#
# Optional (otherwise this does not show the bar):
#
# grep, dd, echo, ls, sed, cut
#
# ls:
# must output the file size at fifth position.
#
# The command line interface also uses:
#
# awk
#
####>-SCHNIPP-<########################################################
bar_cat()
{
# Use this shell function in your own install scripts.
#####################################################
# Options:
# Width of the bar (in ten characters). The default is 76 characters.
test -z "${BAR_WIDTH}" && test -n "${COLUMNS}" && BAR_WIDTH=${COLUMNS}
# Check syntax:
( expr "${BAR_WIDTH}" + 0 >/dev/null 2>&1 ) || BAR_WIDTH=0
BAR_WIDTH=`expr ${BAR_WIDTH} + 0` || BAR_WIDTH=0
test "x${BAR_WIDTH}" = x0 && BAR_WIDTH=76
# Maximal block size to use for dd.
test -n "${BAR_BS}" || BAR_BS=1048567
# BEGIN PERC
# Whether to show a percentage.
test -n "${BAR_PERC}" || BAR_PERC=1
# END PERC
# BEGIN ETA
# Whether to show estimated time of arrival (ETA).
test -n "${BAR_ETA}" || BAR_ETA=1
# END ETA
# Width of the trace display:
# BEGIN TRACE
test -n "${BAR_TRACE_WIDTH}" || BAR_TRACE_WIDTH=10
# END TRACE
# The command to execute for every given file. Each file
# is piped into this command individually. By default, the
# files are simply dumped to stdout.
test -n "${BAR_CMD}" || BAR_CMD=cat
# The characters to be used in the bar
test -n "${BAR_L}" || BAR_L='['
test -n "${BAR_R}" || BAR_R=']'
test -n "${BAR_C0}" || BAR_C0='.'
test -n "${BAR_C1}" || BAR_C1='='
# Additional extension to add to each file:
#BAR_EXT=${BAR_EXT-}
# Whether to clear bar after termination. Otherwise keep the full bar.
#BAR_CLEAR=${BAR_CLEAR-0}
# Unless switched off by user, use the bar by default:
test -n "${BAR_OK}" || BAR_OK=1
#####################################################
BAR_WIDTH=`expr ${BAR_WIDTH} - 3`
bar_trace=''
# BEGIN TRACE
if test "x${BAR_TRACE}" = x1
then
BAR_WIDTH=`expr ${BAR_WIDTH} - ${BAR_TRACE_WIDTH}`
bar_lauf=${BAR_TRACE_WIDTH}
bar_t_space=''
bar_t_dot=''
while test "${bar_lauf}" -gt 1
do
bar_t_space="${bar_t_space} "
bar_t_dot="${bar_t_dot}."
bar_lauf=`expr ${bar_lauf} - 1`
done
bar_trace="${bar_t_space} "
fi
# END TRACE
bar_eta=''
BAR_GET_TIME='echo'
# BEGIN ETA
( expr 1 + ${SECONDS} >/dev/null 2>&1 ) || BAR_ETA=0
if test "x${BAR_ETA}" = x1
then
BAR_GET_TIME='( echo ${SECONDS} )'
BAR_WIDTH=`expr ${BAR_WIDTH} - 6`
bar_eta='--:-- '
fi
# END ETA
bar_perc=''
# BEGIN PERC
if test "x${BAR_PERC}" = x1
then
BAR_WIDTH=`expr ${BAR_WIDTH} - 5`
bar_perc=' 0% '
fi
# END PERC
BAR_GET_SIZE='( ls -l "${BAR_DIR}${bar_file}${BAR_EXT}" | sed "s@ *@ @g" | cut -d " " -f 5 ) 2>/dev/null'
# portable?
# check features:
( ( echo a ) >/dev/null 2>&1 ) || BAR_OK=0
( ( echo a | dd bs=2 count=2 ) >/dev/null 2>&1 ) || BAR_OK=0
( ( echo a | grep a ) >/dev/null 2>&1 ) || BAR_OK=0
( ( echo a | sed 's@ *@ @g' ) >/dev/null 2>&1 ) || BAR_OK=0
( ( echo a | cut -d ' ' -f 1 ) >/dev/null 2>&1 ) || BAR_OK=0
# check ranges:
test "${BAR_WIDTH}" -ge 4 || BAR_OK=0
BAR_ECHO='echo'
BAR_E_C1=''
BAR_E_C2=''
BAR_E_NL='echo'
# Does echo accept -n without signalling an error?
if echo -n abc >/dev/null 2>&1
then
BAR_E_C1='-n'
fi
# Check how to print a line without newline:
if ( ( ${BAR_ECHO} "${BAR_E_C1}" abc ; echo 1,2,3 ) | grep n ) >/dev/null 2>&1
then
# Try echo \c:
if ( ( ${BAR_ECHO} 'xyz\c' ; echo 1,2,3 ) | grep c ) >/dev/null 2>&1
then
# Try printf:
if ( ( printf 'ab%s' c ; echo 1,2,3 ) | grep abc ) >/dev/null 2>&1
then
BAR_ECHO='printf'
BAR_E_C1='%s'
else
BAR_ECHO=':'
BAR_E_C1=''
BAR_E_NL=':'
BAR_OK=0
fi
else
BAR_E_C1=''
BAR_E_C2='\c'
fi
fi
# prepare initial bar:
bar_shown=0
if test "${BAR_OK}" = 1
then
bar_lauf=0
bar_graph=''
while test `expr ${bar_lauf} + 5` -le "${BAR_WIDTH}"
do
bar_graph="${bar_graph}${BAR_C0}${BAR_C0}${BAR_C0}${BAR_C0}${BAR_C0}"
bar_lauf=`expr ${bar_lauf} + 5`
done
while test "${bar_lauf}" -lt "${BAR_WIDTH}"
do
bar_graph="${bar_graph}${BAR_C0}"
bar_lauf=`expr ${bar_lauf} + 1`
done
${BAR_ECHO} "${BAR_E_C1}" "
${bar_trace}${bar_eta}${bar_perc}${BAR_L}${bar_graph}${BAR_R}
${BAR_E_C2}" 1>&2
bar_shown=1
fi
# for shifting large numbers so that expr can handle them:
# Assume we can compute up to 2147483647, thus 9 arbitrary digits.
# We must be able to do + of two numbers of 9 digits length. Ok.
# BEGIN LARGE
( ( test 1999999998 = `expr 999999999 + 999999999` ) >/dev/null 2>&1 ) || BAR_OK=0
bar_large_num="........."
bar_div=""
# END LARGE
bar_numsuff=""
# find size:
bar_size=0
if test -n "${BAR_SIZE}"
then
bar_size=${BAR_SIZE}
# BEGIN LARGE
while expr "${bar_size}" : "${bar_large_num}" >/dev/null 2>&1
do
bar_div="${bar_div}."
bar_numsuff="${bar_numsuff}0"
bar_size=`expr "${bar_size}" : '\(.*\).$'`
done
# END LARGE
BAR_GET_SIZE="echo '${BAR_SIZE}'"
else
for bar_file
do
bar_size1=0
if test -f "${BAR_DIR}${bar_file}${BAR_EXT}"
then
bar_size1=`eval "${BAR_GET_SIZE}"`
# BEGIN LARGE
# divide and upround by pattern matching:
if test -n "${bar_div}"
then
bar_size1=`expr "${bar_size1}" : '\(.*\)'${bar_div}'$'` || bar_size1=0
fi
# adjust if still too large:
while expr "${bar_size1}" : "${bar_large_num}" >/dev/null 2>&1
do
bar_div="${bar_div}."
bar_numsuff="${bar_numsuff}0"
bar_size1=`expr "${bar_size1}" : '\(.*\).$'`
bar_size=`expr "${bar_size}" : '\(.*\).$'` || bar_size=0
done
# upround if necessary:
if test -n "${bar_div}"
then
bar_size1=`expr "${bar_size1}" + 1`
fi
# END LARGE
# add to total size:
bar_size=`expr ${bar_size} + ${bar_size1}`
# BEGIN LARGE
# adjust if still too large:
while expr "${bar_size}" : "${bar_large_num}" >/dev/null 2>&1
do
bar_div="${bar_div}."
bar_numsuff="${bar_numsuff}0"
bar_size=`expr "${bar_size}" : '\(.*\).$'`
done
# END LARGE
else
BAR_OK=0
fi
done
fi
bar_quad=`expr ${BAR_WIDTH} '*' ${BAR_WIDTH}`
test "${bar_size}" -gt "${bar_quad}" || BAR_OK=0
if test "${BAR_OK}" = 0
then
# For some reason, we cannot display the bar. Thus plain operation:
for bar_file
do
if test "${bar_file}" = "/dev/stdin"
then
eval "${BAR_CMD}"
else
eval "${BAR_CMD}" < "${BAR_DIR}${bar_file}${BAR_EXT}"
fi
done
else
# Compute wanted bytes per step:
bar_want_bps=`expr ${bar_size} + ${BAR_WIDTH}`
bar_want_bps=`expr ${bar_want_bps} - 1`
bar_want_bps=`expr ${bar_want_bps} / ${BAR_WIDTH}`
# Compute block count per step to keep within maximum block size:
bar_count=1
if test "${bar_want_bps}" -gt "${BAR_BS}"
then
bar_count=`expr ${bar_want_bps} + ${BAR_BS}`
bar_count=`expr ${bar_count} - 1`
bar_count=`expr ${bar_count} / ${BAR_BS}`
fi
# Compute block size for given count:
bar_wc=`expr ${BAR_WIDTH} '*' ${bar_count}`
bar_bs=`expr ${bar_size} + ${bar_wc}`
bar_bs=`expr ${bar_bs} - 1`
bar_bs=`expr ${bar_bs} / ${bar_wc}`
# Compute bs * count, the bytes per step:
bar_bps=`expr ${bar_bs} '*' ${bar_count}`
# Compute bytes per hundredth:
bar_bph=`expr ${bar_size} + 99`
bar_bph=`expr ${bar_bph} / 100`
# Run loop:
bar_pos=0
bar_graph="${BAR_L}"
bar_cur_char=0
bar_t0=`eval "${BAR_GET_TIME}" 2>/dev/null` || bar_t0=0
for bar_file
do
# BEGIN TRACE
if test "x${BAR_TRACE}" = x1
then
bar_trace=`expr "${bar_file}" : '.*/\([^/][^/]*\)$'` || bar_trace="${bar_file}"
bar_trace=`expr "${bar_trace}${bar_t_space}" : '\('${bar_t_dot}'\)'`
bar_trace="${bar_trace} "
fi
# END TRACE
# Initial character position in bar for file:
bar_char=`expr ${bar_pos} / ${bar_want_bps}` || bar_char=0
while test "${bar_char}" -gt `expr ${bar_cur_char} + 4`
do
bar_graph="${bar_graph}${BAR_C1}${BAR_C1}${BAR_C1}${BAR_C1}${BAR_C1}"
bar_cur_char=`expr ${bar_cur_char} + 5`
done
while test "${bar_char}" -gt "${bar_cur_char}"
do
bar_graph="${bar_graph}${BAR_C1}"
bar_cur_char=`expr ${bar_cur_char} + 1`
done
# Get file size. This must work now (we checked with test -f before).
bar_size1=`eval "${BAR_GET_SIZE}" 2>/dev/null` || bar_size1=0
# BEGIN LARGE
# Divide and upround by pattern matching:
if test -n "${bar_div}"
then
bar_size1=`expr "${bar_size1}" : '\(.*\)'${bar_div}'$'` || bar_size1=0
bar_size1=`expr "${bar_size1}" + 1`
fi
# END LARGE
# loop:
bar_total=0
(
exec 6>&1
exec 5<"${BAR_DIR}${bar_file}${BAR_EXT}"
while test "${bar_total}" -lt "${bar_size1}"
do
dd bs="${bar_bs}" count="${bar_count}${bar_numsuff}" <&5 >&6 2>/dev/null
bar_total=`expr ${bar_total} + ${bar_bps}`
if test "${bar_total}" -gt "${bar_size1}"
then
bar_total="${bar_size1}"
fi
bar_pos1=`expr ${bar_pos} + ${bar_total}`
bar_proz=`expr ${bar_pos1} / ${bar_bph}` || bar_proz=0
# BEGIN PERC
if test "x${BAR_PERC}" = x1
then
bar_perc=" ${bar_proz}% "
bar_perc=`expr "${bar_perc}" : '.*\(.....\)$'`
fi
# END PERC
# BEGIN ETA
if test "x${BAR_ETA}" = x1
then
bar_diff=`eval "${BAR_GET_TIME}" 2>/dev/null` || bar_diff=0
bar_diff=`expr ${bar_diff} - ${bar_t0} 2>/dev/null` || bar_diff=0
bar_100p=`expr 100 - ${bar_proz}` || bar_100p=0
bar_diff=`expr ${bar_diff} '*' ${bar_100p}` || bar_diff=0
bar_diff=`expr ${bar_diff} + ${bar_proz}` || bar_diff=0
bar_diff=`expr ${bar_diff} - 1` || bar_diff=0
bar_diff=`expr ${bar_diff} / ${bar_proz} 2>/dev/null` || bar_diff=0
if test "${bar_diff}" -gt 0
then
bar_t_unit=":"
if test "${bar_diff}" -gt 2700
then
bar_t_uni="h"
bar_diff=`expr ${bar_diff} / 60`
fi
bar_diff_h=`expr ${bar_diff} / 60` || bar_diff_h=0
if test "${bar_diff_h}" -gt 99
then
bar_eta=" ${bar_diff_h}${bar_t_unit} "
else
bar_diff_hi=`expr ${bar_diff_h} '*' 60` || bar_diff_hi=0
bar_diff=`expr ${bar_diff} - ${bar_diff_hi}` || bar_diff=0
bar_diff=`expr "00${bar_diff}" : '.*\(..\)$'`
bar_eta=" ${bar_diff_h}${bar_t_unit}${bar_diff} "
fi
bar_eta=`expr "${bar_eta}" : '.*\(......\)$'`
fi
fi
# END ETA
bar_char=`expr ${bar_pos1} / ${bar_want_bps}` || bar_char=0
while test "${bar_char}" -gt "${bar_cur_char}"
do
bar_graph="${bar_graph}${BAR_C1}"
${BAR_ECHO} "${BAR_E_C1}" "
${bar_trace}${bar_eta}${bar_perc}${bar_graph}${BAR_E_C2}" 1>&2
bar_cur_char=`expr ${bar_cur_char} + 1`
done
done
) | eval "${BAR_CMD}"
bar_pos=`expr ${bar_pos} + ${bar_size1}`
done
# ${BAR_ECHO} "${BAR_E_C1}" "${BAR_R}${BAR_E_C2}" 1>&2
fi
if test "${bar_shown}" = 1
then
# BEGIN TRACE
test "x${BAR_TRACE}" = x1 && bar_trace="${bar_t_space} "
# END TRACE
# BEGIN ETA
test "x${BAR_ETA}" = x1 && bar_eta=' '
# END ETA
if test "x${BAR_CLEAR}" = x1
then
# BEGIN PERC
test "x${BAR_PERC}" = x1 && bar_perc=' '
# END PERC
bar_lauf=0
bar_graph=''
while test `expr ${bar_lauf} + 5` -le "${BAR_WIDTH}"
do
bar_graph="${bar_graph} "
bar_lauf=`expr ${bar_lauf} + 5`
done
while test "${bar_lauf}" -lt "${BAR_WIDTH}"
do
bar_graph="${bar_graph} "
bar_lauf=`expr ${bar_lauf} + 1`
done
${BAR_ECHO} "${BAR_E_C1}" "
${bar_trace}${bar_eta}${bar_perc} ${bar_graph}
${BAR_E_C2}" 1>&2
else
# BEGIN PERC
test "x${BAR_PERC}" = x1 && bar_perc='100% '
# END PERC
bar_lauf=0
bar_graph=''
while test `expr ${bar_lauf} + 5` -le "${BAR_WIDTH}"
do
bar_graph="${bar_graph}${BAR_C1}${BAR_C1}${BAR_C1}${BAR_C1}${BAR_C1}"
bar_lauf=`expr ${bar_lauf} + 5`
done
while test "${bar_lauf}" -lt "${BAR_WIDTH}"
do
bar_graph="${bar_graph}${BAR_C1}"
bar_lauf=`expr ${bar_lauf} + 1`
done
${BAR_ECHO} "${BAR_E_C1}" "
${bar_trace}${bar_eta}${bar_perc}${BAR_L}${bar_graph}${BAR_R}${BAR_E_C2}" 1>&2
${BAR_E_NL} 1>&2
fi
fi
}
####>-SCHNAPP-<########################################################
BAR_AWK_0=''
# Command line interface:
while test -n "$1"
do
case "$1" in
-o|-c|-w|-0|-1|-e|-d|-b|-s|-\[\]|-\[|-\]|-T)
if test -z "$2"
then
echo "$0: Error: A non-empty argument was expected after $1" 1>&2
fi
BAR_ARG="$1"
BAR_OPT="$2"
shift
shift
;;
-o*|-c*|-w*|-0*|-1*|-e*|-d*|-b*|-T*)
BAR_ARG=`expr "$1" : '\(-.\)'`
BAR_OPT=`expr "$1" : '-.\(.*\)$'`
shift
;;
-h|-n|-p|-D|-D-|-q|-V|-t|-E|-L)
BAR_ARG="$1"
BAR_OPT=""
shift
;;
--) shift
break
;;
-*) echo "$0: Error: Unrecognized option: $1" 1>&2
exit 1
;;
*)
break
;;
esac
case "${BAR_ARG}" in
-h) echo 'Usage: bar [-n] [-p] [-q] [-o FILE] [-c CMD] [-s SIZE] [-b SIZE]'
echo ' [-w WIDTH] [-0/1/[/] CHAR] [-d DIR] [-e EXT] [Files]'
echo ' bar -V'
echo ' bar -D'
echo ' bar -D-'
echo 'Options:'
echo ' -h displays help'
echo ' -o FILE sets output file'
echo ' -c CMD sets individual execution command'
echo ' -e EXT append an extension to each file'
echo ' -d DIR prepend this prefix to each file (a directory must end in /)'
echo ' -s SIZE expected number of bytes. Use for pipes. This is a hint'
echo ' only that must be greater or equal to the amount actually'
echo ' processed. Further, this only works for single files.'
echo ' -b SIZE maximal block size (bytes) (default: 1048567)'
echo ' -w WIDTH width in characters (default: terminal width-3 or 76)'
echo ' -0 CHAR character for empty bar (default: .)'
echo ' -1 CHAR character for full bar (default: =)'
echo ' -[ CHAR first character of bar (default: [)'
echo ' -] CHAR last character of bar (default: ])'
echo ' -n clears bar after termination'
echo ' -t traces (=displays) which file is processed'
echo ' -T WIDTH no of characters reserved for the file display of -t'
echo ' -p hides percentage'
echo ' -E hides estimated time display'
echo ' -q hides the whole bar, be quiet'
echo ' -D tries to dump the bar_cat() shell function, then exit.'
echo ' Here, -t, -p, -E remove the corresponding feature completely.'
echo ' Further, -L removes large file support from the code.'
echo ' -D- same as -D, but dumps the function body only'
echo ' -V displays version number'
echo ' -- end of options: only file names follow'
exit 0
;;
-n) BAR_CLEAR=1
;;
-L) BAR_LARGE=0
BAR_AWK_0="${BAR_AWK_0} /END *LARGE/ {x=1} ;"
BAR_AWK_0="${BAR_AWK_0} /BEGIN *LARGE/ {x=0} ;"
;;
-t) BAR_TRACE=1
BAR_AWK_0="${BAR_AWK_0} /END *TRACE/ {x=1} ;"
BAR_AWK_0="${BAR_AWK_0} /BEGIN *TRACE/ {x=0} ;"
;;
-T) BAR_TRACE_WIDTH="${BAR_OPT}"
;;
-q) BAR_OK=0
;;
-p) BAR_PERC=0
BAR_AWK_0="${BAR_AWK_0} /END *PERC/ {x=1} ;"
BAR_AWK_0="${BAR_AWK_0} /BEGIN *PERC/ {x=0} ;"
;;
-E) BAR_ETA=0
BAR_AWK_0="${BAR_AWK_0} /END *ETA/ {x=1} ;"
BAR_AWK_0="${BAR_AWK_0} /BEGIN *ETA/ {x=0} ;"
;;
-V) echo "bar v${BAR_VERSION}"
exit 0
;;
-D) echo "BAR_VERSION=${BAR_VERSION}"
awk "${BAR_AWK_0}"'{sub(/ *#.*$/,"")} ; /^bar_cat/ {x=1} ; {sub(/^ */,"")} ; /./ {if(x)print} ; /^}/ {x=0}' "$0"
exit 0
;;
-D-) echo "BAR_VERSION=${BAR_VERSION}"
awk "${BAR_AWK_0}"'{sub(/ *#.*$/,"")} ; /^}/ {x=0} ; {sub(/^ */,"")} ; /./ {if(x)print} ; /^{/ {x=1}' "$0"
exit 0
;;
-o) exec 1>"${BAR_OPT}"
;;
-c) BAR_CMD="${BAR_OPT}"
;;
-b) BAR_BS="${BAR_OPT}"
if BAR_RAW=`expr "${BAR_BS}" : '\(.*\)k$'`
then
BAR_BS=`expr ${BAR_RAW} '*' 1024`
elif BAR_RAW=`expr "${BAR_BS}" : '\(.*\)M$'`
then
BAR_BS=`expr ${BAR_RAW} '*' 1048567`
fi
;;
-s) BAR_SIZE="${BAR_OPT}"
if BAR_RAW=`expr "${BAR_SIZE}" : '\(.*\)k$'`
then
BAR_SIZE=`expr ${BAR_RAW} '*' 1024`
elif BAR_RAW=`expr "${BAR_SIZE}" : '\(.*\)M$'`
then
BAR_SIZE=`expr ${BAR_RAW} '*' 1048567`
fi
if test "$#" -gt 1
then
echo "Error: -s cannot be specified for multiple input files." 1>&2
exit 1
fi
;;
-e) BAR_EXT="${BAR_OPT}"
;;
-d) BAR_DIR="${BAR_OPT}"
;;
-0) BAR_C0="${BAR_OPT}"
;;
-1) BAR_C1="${BAR_OPT}"
;;
-\[) BAR_L="${BAR_OPT}"
;;
-\]) BAR_R="${BAR_OPT}"
;;
-\[\])
BAR_L="${BAR_OPT}"
BAR_R="${BAR_OPT}"
;;
-w) BAR_WIDTH="${BAR_OPT}"
;;
esac
done
# Invoke main function:
if test "$#" = 0
then
bar_cat /dev/stdin
else
bar_cat "$@"
fi
[/code:1]
