From c559d71c478ada4f73354edc32f3bb9f5370092c Mon Sep 17 00:00:00 2001 From: Tony Duckles Date: Thu, 17 Nov 2016 21:27:36 -0600 Subject: [PATCH] bar v1.4 This is a small shell script intended to be used in portable Unix install scripts for showing progress bars. http://www.theiling.de/projects/bar.html --- bin/bar | 668 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 668 insertions(+) create mode 100755 bin/bar diff --git a/bin/bar b/bin/bar new file mode 100755 index 0000000..84865e6 --- /dev/null +++ b/bin/bar @@ -0,0 +1,668 @@ +#! /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 -- 2.45.2