gstreamer/gst/cothreads/shtool

#!/bin/sh
##
##  GNU shtool -- The GNU Portable Shell Tool
##  Copyright (c) 1994-2000 Ralf S. Engelschall <rse@engelschall.com>
##
##  See http://www.gnu.org/software/shtool/ for more information.
##  See ftp://ftp.gnu.org/gnu/shtool/ for latest version.
##
##  Version:  1.5.0 (01-Jul-2000)
##  Contents: 7/17 available modules
##

##
##  This program is free software; you can redistribute it and/or modify
##  it under the terms of the GNU General Public License as published by
##  the Free Software Foundation; either version 2 of the License, or
##  (at your option) any later version.
##
##  This program is distributed in the hope that it will be useful,
##  but WITHOUT ANY WARRANTY; without even the implied warranty of
##  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
##  General Public License for more details.
##
##  You should have received a copy of the GNU General Public License
##  along with this program; if not, write to the Free Software
##  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
##  USA, or contact Ralf S. Engelschall <rse@engelschall.com>.
##
##  Notice: Given that you include this file verbatim into your own
##  source tree, you are justified in saying that it remains separate
##  from your package, and that this way you are simply just using GNU
##  shtool. So, in this situation, there is no requirement that your
##  package itself is licensed under the GNU General Public License in
##  order to take advantage of GNU shtool.
##

##
##  Usage: shtool [<options>] [<cmd-name> [<cmd-options>] [<cmd-args>]]
##
##  Available commands:
##    echo       Print string with optional construct expansion
##    install    Install a program, script or datafile
##    mkdir      Make one or more directories
##    fixperm    Fix file permissions inside a source tree
##    tarball    Roll distribution tarballs
##    scpp       Sharing C Pre-Processor
##    version    Maintain a version information file
##
##  Not available commands (because module was not built-in):
##    mdate      Pretty-print modification time of a file or dir
##    table      Pretty-print a field-separated list as a table
##    prop       Display progress with a running propeller
##    move       Move files with simultaneous substitution
##    mkln       Make link with calculation of relative paths
##    mkshadow   Make a shadow tree through symbolic links
##    guessos    Simple operating system guesser
##    arx        Extended archive command
##    slo        Separate linker options by library class
##    path       Deal with program paths
##

if [ $# -eq 0 ]; then
    echo "$0:Error: invalid command line" 1>&2
    echo "$0:Hint:  run \`$0 -h' for usage" 1>&2
    exit 1
fi
if [ ".$1" = ".-h" -o ".$1" = ".--help" ]; then
    echo "This is GNU shtool, version 1.5.0 (01-Jul-2000)"
    echo "Copyright (c) 1994-2000 Ralf S. Engelschall <rse@engelschall.com>"
    echo "Report bugs to <bug-shtool@gnu.org>"
    echo ''
    echo "Usage: shtool [<options>] [<cmd-name> [<cmd-options>] [<cmd-args>]]" 
    echo ''
    echo 'Available global <options>:'
    echo '  -v, --version   display shtool version information'
    echo '  -h, --help      display shtool usage help page (this one)'
    echo '  -d, --debug     display shell trace information'
    echo '  -r, --recreate  recreate this shtool script via shtoolize'
    echo ''
    echo 'Available <cmd-name> [<cmd-options>] [<cmd-args>]:'
    echo '  echo     [-n] [-e] [<str> ...]'
    echo '  install  [-v] [-t] [-c] [-C] [-s] [-m<mode>] [-o<owner>] [-g<group>]'
    echo '           [-e<ext>] <file> [<file> ...] <path>'
    echo '  mkdir    [-t] [-f] [-p] [-m<mode>] <dir> [<dir> ...]'
    echo '  fixperm  [-v] [-t] <path> [<path> ...]'
    echo '  tarball  [-t] [-v] [-o <tarball>] [-c <prog>] [-d <dir>] [-u'
    echo '           <user>] [-g <group>] [-e <pattern>] <path> [<path> ...]'
    echo '  scpp     [-v] [-p] [-f<filter>] [-o<ofile>] [-t<tfile>] [-M<mark>]'
    echo '           [-D<dname>] [-C<cname>] <file> [<file> ...]'
    echo '  version  [-l<lang>] [-n<name>] [-p<prefix>] [-s<version>] [-e]'
    echo '           [-i<knob>] [-d<type>] <file>'
    echo ''
    echo 'Not available <cmd-name> (because module was not built-in):'
    echo '  mdate    [-n] [-z] [-s] [-d] [-f<str>] [-o<spec>] <path>'
    echo '  table    [-F<sep>] [-w<width>] [-c<cols>] [-s<strip>] <str><sep><str>...'
    echo '  prop     [-p<str>]'
    echo '  move     [-v] [-t] [-e] [-p] <src-file> <dst-file>'
    echo '  mkln     [-t] [-f] [-s] <src-path> [<src-path> ...] <dst-path>'
    echo '  mkshadow [-v] [-t] [-a] <src-dir> <dst-dir>'
    echo '  guessos  '
    echo '  arx      [-t] [-C<cmd>] <op> <archive> [<file> ...]'
    echo '  slo      [-p<str>] -- -L<dir> -l<lib> [-L<dir> -l<lib> ...]'
    echo '  path     [-s] [-r] [-d] [-b] [-m] [-p<path>] <str> [<str> ...]'
    echo ''
    exit 0
fi
if [ ".$1" = ".-v" -o ".$1" = ."--version" ]; then
    echo "GNU shtool 1.5.0 (01-Jul-2000)"
    exit 0
fi
if [ ".$1" = ".-r" -o ".$1" = ."--recreate" ]; then
    shtoolize -oshtool echo install mkdir fixperm tarball scpp version
    exit 0
fi
if [ ".$1" = ".-d" -o ".$1" = ."--debug" ]; then
    shift
    set -x
fi
name=`echo "$0" | sed -e 's;.*/\([^/]*\)$;\1;' -e 's;-sh$;;' -e 's;\.sh$;;'`
case "$name" in
    echo|install|mkdir|fixperm|tarball|scpp|version )
        #   implicit tool command selection
        tool="$name"
        ;;
    * )
        #   explicit tool command selection
        tool="$1"
        shift
        ;;
esac
arg_spec=""
opt_spec=""
gen_tmpfile=no

##
##  DISPATCH INTO SCRIPT PROLOG
##

case $tool in
    echo )
        str_tool="echo"
        str_usage="[-n] [-e] [<str> ...]"
        arg_spec="0+"
        opt_spec="n.e."
        opt_n=no
        opt_e=no
        ;;
    install )
        str_tool="install"
        str_usage="[-v] [-t] [-c] [-C] [-s] [-m<mode>] [-o<owner>] [-g<group>] [-e<ext>] <file> [<file> ...] <path>"
        arg_spec="2+"
        opt_spec="v.t.c.C.s.m:o:g:e:"
        opt_v=no
        opt_t=no
        opt_c=no
        opt_C=no
        opt_s=no
        opt_m=""
        opt_o=""
        opt_g=""
        opt_e=""
        ;;
    mkdir )
        str_tool="mkdir"
        str_usage="[-t] [-f] [-p] [-m<mode>] <dir> [<dir> ...]"
        arg_spec="1+"
        opt_spec="t.f.p.m:"
        opt_t=no
        opt_f=no
        opt_p=no
        opt_m=""
        ;;
    fixperm )
        str_tool="fixperm"
        str_usage="[-v] [-t] <path> [<path> ...]"
        arg_spec="1+"
        opt_spec="v.t."
        opt_v=no
        opt_t=no
        ;;
    tarball )
        str_tool="tarball"
        str_usage="[-t] [-v] [-o <tarball>] [-c <prog>] [-d <dir>] [-u <user>] [-g <group>] [-e <pattern>] <path> [<path> ...]"
        gen_tmpfile=yes
        arg_spec="1+"
        opt_spec="t.v.o:c:d:u:g:e:"
        opt_t=no
        opt_v=no
        opt_o=""
        opt_c=""
        opt_d=""
        opt_u=""
        opt_g=""
        opt_e="CVS,\\.cvsignore,\\.[oa]\$"
        ;;
    scpp )
        str_tool="scpp"
        str_usage="[-v] [-p] [-f<filter>] [-o<ofile>] [-t<tfile>] [-M<mark>] [-D<dname>] [-C<cname>] <file> [<file> ...]"
        gen_tmpfile=yes
        arg_spec="1+"
        opt_spec="v.p.f+o:t:M:D:C:"
        opt_v=no
        opt_p=no
        opt_f=""
        opt_o="lib.h"
        opt_t="lib.h.in"
        opt_M="%%MARK%%"
        opt_D="cpp"
        opt_C="intern"
        ;;
    version )
        str_tool="version"
        str_usage="[-l<lang>] [-n<name>] [-p<prefix>] [-s<version>] [-e] [-i<knob>] [-d<type>] <file>"
        arg_spec="1="
        opt_spec="l:n:p:s:i:e.d:"
        opt_l="txt"
        opt_n="unknown"
        opt_p=""
        opt_s=""
        opt_e="no"
        opt_i=""
        opt_d="short"
        ;;
    -* )
        echo "$0:Error: unknown option \`$tool'" 2>&1
        echo "$0:Hint:  run \`$0 -h' for usage" 2>&1
        exit 1
        ;;
    * )
        echo "$0:Error: unknown command \`$tool'" 2>&1
        echo "$0:Hint:  run \`$0 -h' for usage" 2>&1
        exit 1
        ;;
esac

##
##  COMMON UTILITY CODE
##

#   determine name of tool
if [ ".$tool" != . ]; then
    #   used inside shtool script
    toolcmd="$0 $tool"
    toolcmdhelp="shtool $tool"
    msgprefix="shtool:$tool"
else
    #   used as standalone script
    toolcmd="$0"
    toolcmdhelp="sh $0"
    msgprefix="$str_tool"
fi

#   parse argument specification string
eval `echo $arg_spec |\
      sed -e 's/^\([0-9]*\)\([+=]\)/arg_NUMS=\1; arg_MODE=\2/'`

#   parse option specification string
eval `echo h.$opt_spec |\
      sed -e 's/\([a-zA-Z0-9]\)\([.:+]\)/opt_MODE_\1=\2;/g'`

#   interate over argument line
opt_PREV=''
while [ $# -gt 0 ]; do
    #   special option stops processing
    if [ ".$1" = ".--" ]; then
        shift
        break
    fi

    #   determine option and argument
    opt_ARG_OK=no
    if [ ".$opt_PREV" != . ]; then
        #   merge previous seen option with argument
        opt_OPT="$opt_PREV"
        opt_ARG="$1"
        opt_ARG_OK=yes
        opt_PREV=''
    else
        #   split argument into option and argument
        case "$1" in
            -[a-zA-Z0-9]*)
                eval `echo "x$1" |\
                      sed -e 's/^x-\([a-zA-Z0-9]\)/opt_OPT="\1";/' \
                          -e 's/";\(.*\)$/"; opt_ARG="\1"/'`
                ;;
            -[a-zA-Z0-9])
                opt_OPT=`echo "x$1" | cut -c3-`
                opt_ARG=''
                ;;
            *)
                break
                ;;
        esac
    fi

    #   eat up option
    shift

    #   determine whether option needs an argument
    eval "opt_MODE=\$opt_MODE_${opt_OPT}"
    if [ ".$opt_ARG" = . -a ".$opt_ARG_OK" != .yes ]; then
        if [ ".$opt_MODE" = ".:" -o ".$opt_MODE" = ".+" ]; then
            opt_PREV="$opt_OPT"
            continue
        fi
    fi

    #   process option
    case $opt_MODE in
        '.' )
            #   boolean option
            eval "opt_${opt_OPT}=yes"
            ;;
        ':' )
            #   option with argument (multiple occurances override)
            eval "opt_${opt_OPT}=\"\$opt_ARG\""
            ;;
        '+' )
            #   option with argument (multiple occurances append)
            eval "opt_${opt_OPT}=\"\$opt_${opt_OPT} \$opt_ARG\""
            ;;
        * )
            echo "$msgprefix:Error: unknown option: \`-$opt_OPT'" 1>&2
            echo "$msgprefix:Hint:  run \`$toolcmdhelp -h' or \`man shtool' for details" 1>&2
            exit 1
            ;;
    esac
done
if [ ".$opt_PREV" != . ]; then
    echo "$msgprefix:Error: missing argument to option \`-$opt_PREV'" 1>&2
    echo "$msgprefix:Hint:  run \`$toolcmdhelp -h' or \`man shtool' for details" 1>&2
    exit 1
fi

#   process help option
if [ ".$opt_h" = .yes ]; then
    echo "Usage: $toolcmdhelp $str_usage"
    exit 0
fi

#   complain about incorrect number of arguments
case $arg_MODE in
    '=' )
        if [ $# -ne $arg_NUMS ]; then
            echo "$msgprefix:Error: invalid number of arguments (exactly $arg_NUMS expected)" 1>&2
            echo "$msgprefix:Hint:  run \`$toolcmd -h' or \`man shtool' for details" 1>&2
            exit 1
        fi
        ;;
    '+' )
        if [ $# -lt $arg_NUMS ]; then
            echo "$msgprefix:Error: invalid number of arguments (at least $arg_NUMS expected)" 1>&2
            echo "$msgprefix:Hint:  run \`$toolcmd -h' or \`man shtool' for details" 1>&2
            exit 1
        fi
        ;;
esac

#   establish a temporary file on request
if [ ".$gen_tmpfile" = .yes ]; then
    if [ ".$TMPDIR" != . ]; then
        tmpdir="$TMPDIR"
    elif [ ".$TEMPDIR" != . ]; then
        tmpdir="$TEMPDIR"
    else
        tmpdir="/tmp"
    fi
    tmpfile="$tmpdir/.shtool.$$"
    rm -f $tmpfile >/dev/null 2>&1
    touch $tmpfile
fi

##
##  DISPATCH INTO SCRIPT BODY
##

case $tool in

echo )
    ##
    ##  echo -- Print string with optional construct expansion
    ##  Copyright (c) 1998-2000 Ralf S. Engelschall <rse@engelschall.com>
    ##  Originally written for WML as buildinfo
    ##
    
    text="$*"
    
    #   check for broken escape sequence expansion
    seo=''
    bytes=`echo '\1' | wc -c | awk '{ printf("%s", $1); }'`
    if [ ".$bytes" != .3 ]; then
        bytes=`echo -E '\1' | wc -c | awk '{ printf("%s", $1); }'`
        if [ ".$bytes" = .3 ]; then
            seo='-E'
        fi
    fi
    
    #   check for existing -n option (to suppress newline)
    minusn=''
    bytes=`echo -n 123 2>/dev/null | wc -c | awk '{ printf("%s", $1); }'`
    if [ ".$bytes" = .3 ]; then
        minusn='-n'
    fi
    
    #   determine terminal bold sequence
    term_bold='' 
    term_norm=''
    if [ ".$opt_e" = .yes -a ".`echo $text | egrep '%[Bb]'`" != . ]; then
        case $TERM in
            #   for the most important terminal types we directly know the sequences
            xterm|xterm*|vt220|vt220*)
                term_bold=`awk 'BEGIN { printf("%c%c%c%c", 27, 91, 49, 109); }' </dev/null 2>/dev/null`
                term_norm=`awk 'BEGIN { printf("%c%c%c", 27, 91, 109); }' </dev/null 2>/dev/null`
                ;;
            vt100|vt100*)
                term_bold=`awk 'BEGIN { printf("%c%c%c%c%c%c", 27, 91, 49, 109, 0, 0); }' </dev/null 2>/dev/null`
                term_norm=`awk 'BEGIN { printf("%c%c%c%c%c", 27, 91, 109, 0, 0); }' </dev/null 2>/dev/null`
                ;;
            #   for all others, we try to use a possibly existing `tput' or `tcout' utility
            * )
                paths=`echo $PATH | sed -e 's/:/ /g'`
                for tool in tput tcout; do
                    for dir in $paths; do
                        if [ -r "$dir/$tool" ]; then
                            for seq in bold md smso; do # 'smso' is last
                                bold="`$dir/$tool $seq 2>/dev/null`"
                                if [ ".$bold" != . ]; then
                                    term_bold="$bold"
                                    break
                                fi
                            done
                            if [ ".$term_bold" != . ]; then
                                for seq in sgr0 me rmso reset; do # 'reset' is last
                                    norm="`$dir/$tool $seq 2>/dev/null`"
                                    if [ ".$norm" != . ]; then
                                        term_norm="$norm"
                                        break
                                    fi
                                done
                            fi
                            break
                        fi
                    done
                    if [ ".$term_bold" != . -a ".$term_norm" != . ]; then
                        break;
                    fi
                done
                ;;
        esac
        if [ ".$term_bold" = . -o ".$term_norm" = . ]; then
            echo "$msgprefix:Warning: unable to determine terminal sequence for bold mode" 1>&2
        fi
    fi
    
    #   determine user name
    username=''
    if [ ".$opt_e" = .yes -a ".`echo $text | egrep '%[uU]'`" != . ]; then
        username="$LOGNAME"
        if [ ".$username" = . ]; then
            username="$USER"
            if [ ".$username" = . ]; then
                username="`(whoami) 2>/dev/null |\
                           awk '{ printf("%s", $1); }'`"
                if [ ".$username" = . ]; then
                    username="`(who am i) 2>/dev/null |\
                               awk '{ printf("%s", $1); }'`"
                    if [ ".$username" = . ]; then
                        username='unknown'
                    fi
                fi
            fi
        fi
    fi
    
    #   determine user id
    userid=''
    if [ ".$opt_e" = .yes -a ".`echo $text | egrep '%U'`" != . ]; then
        userid="`(id -u) 2>/dev/null`"
        if [ ".$userid" = . ]; then
            str="`(id) 2>/dev/null`"
            if [ ".`echo $str | grep '^uid[ 	]*=[ 	]*[0-9]*('`" != . ]; then
                userid=`echo $str | sed -e 's/^uid[ 	]*=[ 	]*//' -e 's/(.*//'`
            fi
            if [ ".$userid" = . ]; then
                userid=`egrep "^${username}:" /etc/passwd 2>/dev/null | \
                        sed -e 's/[^:]*:[^:]*://' -e 's/:.*$//'`
                if [ ".$userid" = . ]; then
                    userid=`(ypcat passwd) 2>/dev/null |
                            egrep "^${username}:" | \
                            sed -e 's/[^:]*:[^:]*://' -e 's/:.*$//'`
                    if [ ".$userid" = . ]; then
                        userid='?'
                    fi
                fi
            fi
        fi
    fi
    
    #   determine host name
    hostname=''
    if [ ".$opt_e" = .yes -a ".`echo $text | egrep '%h'`" != . ]; then
        hostname="`(uname -n) 2>/dev/null |\
                   awk '{ printf("%s", $1); }'`"
        if [ ".$hostname" = . ]; then
            hostname="`(hostname) 2>/dev/null |\
                       awk '{ printf("%s", $1); }'`"
            if [ ".$hostname" = . ]; then
                hostname='unknown'
            fi
        fi
        case $hostname in
            *.* )
                domainname=".`echo $hostname | cut -d. -f2-`"
                hostname="`echo $hostname | cut -d. -f1`"
                ;;
        esac
    fi
    
    #   determine domain name
    domainname=''
    if [ ".$opt_e" = .yes -a ".`echo $text | egrep '%d'`" != . ]; then
        if [ ".$domainname" = . ]; then
            if [ -f /etc/resolv.conf ]; then
                domainname="`egrep '^[ 	]*domain' /etc/resolv.conf | head -1 |\
                             sed -e 's/.*domain//' \
                                 -e 's/^[ 	]*//' -e 's/^ *//' -e 's/^	*//' \
                                 -e 's/^\.//' -e 's/^/./' |\
                             awk '{ printf("%s", $1); }'`"
                if [ ".$domainname" = . ]; then
                    domainname="`egrep '^[ 	]*search' /etc/resolv.conf | head -1 |\
                                 sed -e 's/.*search//' \
                                     -e 's/^[ 	]*//' -e 's/^ *//' -e 's/^	*//' \
                                     -e 's/ .*//' -e 's/	.*//' \
                                     -e 's/^\.//' -e 's/^/./' |\
                                 awk '{ printf("%s", $1); }'`"
                fi
            fi
        fi
    fi
    
    #   determine current time
    time_day=''
    time_month=''
    time_year=''
    time_monthname=''
    if [ ".$opt_e" = .yes -a ".`echo $text | egrep '%[DMYm]'`" != . ]; then
        time_day=`date '+%d'`
        time_month=`date '+%m'`
        time_year=`date '+%Y' 2>/dev/null`
        if [ ".$time_year" = . ]; then
            time_year=`date '+%y'`
            case $time_year in
                [5-9][0-9]) time_year="19$time_year" ;;
                [0-4][0-9]) time_year="20$time_year" ;;
            esac
        fi
        case $time_month in
            1|01) time_monthname='Jan' ;;
            2|02) time_monthname='Feb' ;;
            3|03) time_monthname='Mar' ;;
            4|04) time_monthname='Apr' ;;
            5|05) time_monthname='May' ;;
            6|06) time_monthname='Jun' ;;
            7|07) time_monthname='Jul' ;;
            8|08) time_monthname='Aug' ;;
            9|09) time_monthname='Sep' ;;
              10) time_monthname='Oct' ;;
              11) time_monthname='Nov' ;;
              12) time_monthname='Dec' ;;
        esac
    fi
    
    #   expand special ``%x'' constructs
    if [ ".$opt_e" = .yes ]; then
        text=`echo $seo "$text" |\
              sed -e "s/%B/${term_bold}/g" \
                  -e "s/%b/${term_norm}/g" \
                  -e "s/%u/${username}/g" \
                  -e "s/%U/${userid}/g" \
                  -e "s/%h/${hostname}/g" \
                  -e "s/%d/${domainname}/g" \
                  -e "s/%D/${time_day}/g" \
                  -e "s/%M/${time_month}/g" \
                  -e "s/%Y/${time_year}/g" \
                  -e "s/%m/${time_monthname}/g" 2>/dev/null`
    fi
    
    #   create output
    if [ .$opt_n = .no ]; then
        echo $seo "$text"
    else
        #   the harder part: echo -n is best, because
        #   awk may complain about some \xx sequences.
        if [ ".$minusn" != . ]; then
            echo $seo $minusn "$text"
        else
            echo dummy | awk '{ printf("%s", TEXT); }' TEXT="$text"
        fi
    fi
    ;;

install )
    ##
    ##  install -- Install a program, script or datafile
    ##  Copyright (c) 1997-2000 Ralf S. Engelschall <rse@engelschall.com>
    ##  Originally written for shtool
    ##
    
    #   determine source(s) and destination 
    argc=$#
    srcs=""
    while [ $# -gt 1 ]; do
        srcs="$srcs $1"
        shift
    done
    dstpath="$1"
    
    #   type check for destination
    dstisdir=0
    if [ -d $dstpath ]; then
        dstpath=`echo "$dstpath" | sed -e 's:/$::'`
        dstisdir=1
    fi
    
    #   consistency check for destination
    if [ $argc -gt 2 -a $dstisdir = 0 ]; then
        echo "$msgprefix:Error: multiple sources require destination to be directory" 1>&2
        exit 1
    fi
    
    #   iterate over all source(s)
    for src in $srcs; do
        dst=$dstpath
    
        #  If destination is a directory, append the input filename
        if [ $dstisdir = 1 ]; then
            dstfile=`echo "$src" | sed -e 's;.*/\([^/]*\)$;\1;'`
            dst="$dst/$dstfile"
        fi
    
        #  Add a possible extension to src and dst
        if [ ".$opt_e" != . ]; then
            src="$src$opt_e"
            dst="$dst$opt_e"
        fi
    
        #  Check for correct arguments
        if [ ".$src" = ".$dst" ]; then
            echo "$msgprefix:Warning: source and destination are the same - skipped" 1>&2
            continue
        fi
        if [ -d "$src" ]; then
            echo "$msgprefix:Warning: source \`$src' is a directory - skipped" 1>&2
            continue
        fi
    
        #  Make a temp file name in the destination directory
        dsttmp=`echo $dst |\
                sed -e 's;[^/]*$;;' -e 's;\(.\)/$;\1;' -e 's;^$;.;' \
                    -e "s;\$;/#INST@$$#;"`
    
        #  Verbosity
        if [ ".$opt_v" = .yes ]; then
            echo "$src -> $dst" 1>&2
        fi
    
        #  Copy or move the file name to the temp name
        #  (because we might be not allowed to change the source)
        if [ ".$opt_C" = .yes ]; then
            opt_c=yes
        fi
        if [ ".$opt_c" = .yes ]; then
            if [ ".$opt_t" = .yes ]; then
                echo "cp $src $dsttmp" 1>&2
            fi
            cp $src $dsttmp || exit $?
        else
            if [ ".$opt_t" = .yes ]; then
                echo "mv $src $dsttmp" 1>&2
            fi
            mv $src $dsttmp || exit $?
        fi
    
        #  Adjust the target file
        #  (we do chmod last to preserve setuid bits)
        if [ ".$opt_s" = .yes ]; then
            if [ ".$opt_t" = .yes ]; then
                echo "strip $dsttmp" 1>&2
            fi
            strip $dsttmp || exit $?
        fi
        if [ ".$opt_o" != . ]; then
            if [ ".$opt_t" = .yes ]; then
                echo "chown $opt_o $dsttmp" 1>&2
            fi
            chown $opt_o $dsttmp || exit $?
        fi
        if [ ".$opt_g" != . ]; then
            if [ ".$opt_t" = .yes ]; then
                echo "chgrp $opt_g $dsttmp" 1>&2
            fi
            chgrp $opt_g $dsttmp || exit $?
        fi
        if [ ".$opt_m" != . ]; then
            if [ ".$opt_t" = .yes ]; then
                echo "chmod $opt_m $dsttmp" 1>&2
            fi
            chmod $opt_m $dsttmp || exit $?
        fi
    
        #   Determine whether to do a quick install
        #   (has to be done _after_ the strip was already done)
        quick=no
        if [ ".$opt_C" = .yes ]; then
            if [ -r $dst ]; then
                if cmp -s $src $dst; then
                    quick=yes
                fi
            fi
        fi
    
        #   Finally install the file to the real destination
        if [ $quick = yes ]; then
            if [ ".$opt_t" = .yes ]; then
                echo "rm -f $dsttmp" 1>&2
            fi
            rm -f $dsttmp
        else
            if [ ".$opt_t" = .yes ]; then
                echo "rm -f $dst && mv $dsttmp $dst" 1>&2
            fi
            rm -f $dst && mv $dsttmp $dst
        fi
    done
    ;;

mkdir )
    ##
    ##  mkdir -- Make one or more directories
    ##  Copyright (c) 1996-2000 Ralf S. Engelschall <rse@engelschall.com>
    ##  Originally written for public domain by Noah Friedman <friedman@prep.ai.mit.edu>
    ##  Cleaned up and enhanced for shtool
    ##
    
    errstatus=0
    for p in ${1+"$@"}; do
        #   if the directory already exists...
        if [ -d "$p" ]; then
            if [ ".$opt_f" = .no ] && [ ".$opt_p" = .no ]; then
                echo "$msgprefix:Error: directory already exists: $p" 1>&2
                errstatus=1
                break
            else
                continue
            fi
        fi
        #   if the directory has to be created...
        if [ ".$opt_p" = .no ]; then
            if [ ".$opt_t" = .yes ]; then
                echo "mkdir $p" 1>&2
            fi
            mkdir $p || errstatus=$?
        else
            #   the smart situation
            set fnord `echo ":$p" |\
                       sed -e 's/^:\//%/' \
                           -e 's/^://' \
                           -e 's/\// /g' \
                           -e 's/^%/\//'`
            shift
            pathcomp=''
            for d in ${1+"$@"}; do
                pathcomp="$pathcomp$d"
                case "$pathcomp" in
                    -* ) pathcomp="./$pathcomp" ;;
                esac
                if [ ! -d "$pathcomp" ]; then
                    if [ ".$opt_t" = .yes ]; then
                        echo "mkdir $pathcomp" 1>&2
                    fi
                    mkdir $pathcomp || errstatus=$?
                    if [ ".$opt_m" != . ]; then
                        if [ ".$opt_t" = .yes ]; then
                            echo "chmod $opt_m $pathcomp" 1>&2
                        fi
                        chmod $opt_m $pathcomp || errstatus=$?
                    fi
                fi
                pathcomp="$pathcomp/"
            done
        fi
    done
    exit $errstatus
    ;;

fixperm )
    ##
    ##  fixperm -- Fix file permissions inside a source tree
    ##  Copyright (c) 1996-2000 Ralf S. Engelschall <rse@engelschall.com>
    ##  Originally written for ePerl
    ##
    
    paths="$*"
    
    #   check whether the test command supports the -x option
    if [ -x /bin/sh ] 2>/dev/null; then
        minusx="-x"
    else
        minusx="-r"
    fi
    
    #   iterate over paths
    for p in $paths; do
        for file in `find $p -depth -print`; do
            if [ -f $file ]; then
                if [ $minusx $file ]; then
                    if [ ".$opt_v" = .yes ]; then
                        echo "-rwxrwxr-x $file" 2>&1
                    fi
                    if [ ".$opt_t" = .yes ]; then
                        echo "chmod 775 $file" 2>&1
                    fi
                    chmod 775 $file
                else
                    if [ ".$opt_v" = .yes ]; then
                        echo "-rw-rw-r-- $file" 2>&1
                    fi
                    if [ ".$opt_t" = .yes ]; then
                        echo "chmod 664 $file" 2>&1
                    fi
                    chmod 664 $file
                fi
                continue
            fi
            if [ -d $file ]; then
                if [ ".$opt_v" = .yes ]; then
                    echo "drwxrwxr-x $file" 2>&1
                fi
                if [ ".$opt_t" = .yes ]; then
                    echo "chmod 775 $file" 2>&1
                fi
                chmod 775 $file
                continue
            fi
            if [ ".$opt_v" = .yes ]; then
                echo "?????????? $file" 2>&1
            fi
        done
    done
    ;;

tarball )
    ##
    ##  tarball -- Roll distribution tarballs
    ##  Copyright (c) 1999-2000 Ralf S. Engelschall <rse@engelschall.com>
    ##  Originally written for shtool
    ##
    
    srcs="$*"
    
    #   check whether the test command supports the -x option
    if [ -x /bin/sh ] 2>/dev/null; then
        minusx="-x"
    else
        minusx="-r"
    fi
    
    #   find the tools
    paths="`echo $PATH |\
            sed -e 's%/*:%:%g' -e 's%/*$%%' \
                -e 's/^:/.:/' -e 's/::/:.:/g' -e 's/:$/:./' \
                -e 's/:/ /g'`"
    for spec in find:gfind,find tar:gtar,tar tardy:tardy,tarcust; do
        prg=`echo $spec | sed -e 's/:.*$//'`
        tools=`echo $spec | sed -e 's/^.*://'`
        eval "prg_${prg}=''"
        #   iterate over tools
        for tool in `echo $tools | sed -e 's/,/ /g'`; do
            #   iterate over paths
            for path in $paths; do
                if [ $minusx "$path/$tool" ] && [ ! -d "$path/$tool" ]; then
                    eval "prg_${prg}=\"$path/$tool\""
                    break
                fi
            done
            eval "val=\$prg_${prg}"
            if [ ".$val" != . ]; then
                break
            fi
        done
    done
    
    #   expand source paths
    exclude=''
    for pat in `echo $opt_e | sed 's/,/ /g'`; do
        exclude="$exclude | grep -v '$pat'"
    done
    if [ ".$opt_t" = .yes ]; then
        echo "cp /dev/null $tmpfile.lst" 1>&2
    fi
    cp /dev/null $tmpfile.lst
    for src in $srcs; do
        if [ -d $src ]; then
            if [ ".$opt_t" = .yes ]; then
                echo "(cd $src && $prg_find . -type f -depth -print) | sed -e 's:^\\.\$::' -e 's:^\\./::' | cat $exclude >>$tmpfile.lst" 1>&2
            fi
            (cd $src && find . -type f -depth -print) |\
            sed -e 's:^\.$::' -e 's:^\./::' | eval cat $exclude >>$tmpfile.lst
        else
            if [ ".$opt_t" = .yes ]; then
                echo "echo $src >>$tmpfile.lst" 1>&2
            fi
            echo $src >>$tmpfile.lst
        fi
    done
    sort <$tmpfile.lst >$tmpfile.lst.n
    mv $tmpfile.lst.n $tmpfile.lst
    if [ ".$opt_v" = .yes ]; then
        cat $tmpfile.lst | sed -e 's/^/  /' 1>&2
    fi
    
    #   determine tarball file and directory name
    if [ ".$opt_o" != . ]; then
        tarfile="$opt_o"
        if [ ".$opt_d" != . ]; then
            tarname="$opt_d"
        else
            tarname=`echo $tarfile | sed -e 's/\.tar.*$//' -e 's;.*/\([^/]*\)$;\1;'`
        fi
    else
        if [ ".$opt_d" != . ]; then
            tarname="$opt_d"
        elif [ -d "$from" ]; then
            tarname=`echo $from | sed -e 's;.*/\([^/]*\)$;\1;'`
        else
            tarname="out"
        fi
        tarfile="$tarname.tar"
    fi
    
    #   roll the tarball
    compress=''
    if [ ".$opt_c" != . ]; then
        compress="| $opt_c"
    fi
    if [ ".$prg_tardy" != . ]; then
        #   the elegant hackers way
        tardy_opt="--prefix=$tarname"
        tardy_opt="$tardy_opt --user_number=0 --group_number=0" # security!
        if [ ".$opt_u" != . ]; then
            tardy_opt="$tardy_opt --user_name=$opt_u"
        fi
        if [ ".$opt_g" != . ]; then
            tardy_opt="$tardy_opt --group_name=$opt_g"
        fi
        if [ ".$opt_t" = .yes ]; then
            echo "cat $tmpfile.lst | xargs $prg_tar cf - | $prg_tardy $tardy_opt | cat $compress >$tmpfile.out" 1>&2
        fi
        cat $tmpfile.lst |\
        xargs $prg_tar cf - |\
        $prg_tardy $tardy_opt |\
        eval cat $compress >$tmpfile.out
        if [ ".$opt_t" = .yes ]; then
            echo "cp $tmpfile.out $tarfile" 1>&2
        fi
        cp $tmpfile.out $tarfile
    else
        #  the portable standard way
        if [ ".$opt_t" = .yes ]; then
            echo "mkdir $tmpdir/$tarname" 1>&2
        fi
        mkdir $tmpdir/$tarname || exit 1
        if [ ".$opt_t" = .yes ]; then
            echo "cat $tmpfile.lst | xargs $prg_tar cf - | (cd $tmpdir/$tarname && $prg_tar xf -)" 1>&2
        fi
        cat $tmpfile.lst |\
        xargs $prg_tar cf - |\
        (cd $tmpdir/$tarname && $prg_tar xf -)
        if [ ".$opt_u" != . ]; then
            if [ ".$opt_t" = .yes ]; then
                echo "chown -R $opt_u $tmpdir/$tarname >/dev/null 2>&1" 2>&1
            fi
            chown -R $opt_u $tmpdir/$tarname >/dev/null 2>&1 ||\
            echo "$msgprefix:Warning: cannot set user name \`$opt_u' (would require root priviledges)"
        fi
        if [ ".$opt_g" != . ]; then
            if [ ".$opt_t" = .yes ]; then
                echo "chgrp -R $opt_g $tmpdir/$tarname >/dev/null 2>&1" 2>&1
            fi
            chgrp -R $opt_g $tmpdir/$tarname >/dev/null 2>&1 ||\
            echo "$msgprefix:Warning: cannot set group name \`$opt_g' (would require root priviledges)"
        fi
        if [ ".$opt_t" = .yes ]; then
            echo "(cd $tmpdir && $prg_find $tarname -type f -depth -print | sort | xargs $prg_tar cf -) | cat $compress >$tmpfile.out" 1>&2
        fi
        (cd $tmpdir && $prg_find $tarname -type f -depth -print | sort | xargs $prg_tar cf -) |\
        eval cat $compress >$tmpfile.out
        if [ ".$opt_t" = .yes ]; then
            echo "cp $tmpfile.out $tarfile" 1>&2
        fi
        cp $tmpfile.out $tarfile
        if [ ".$opt_t" = .yes ]; then
            echo "rm -rf $tmpdir/$tarname" 1>&2
        fi
        rm -rf $tmpdir/$tarname
    fi
    
    #   cleanup
    if [ ".$opt_t" = .yes ]; then
        echo "rm -f $tmpfile.lst $tmpfile.out" 1>&2
    fi
    rm -f $tmpfile.lst $tmpfile.out
    ;;

scpp )
    ##
    ##  scpp -- Sharing C Pre-Processor
    ##  Copyright (c) 1999-2000 Ralf S. Engelschall <rse@engelschall.com>
    ##  Originally written for GNU Pth
    ##
    
    srcs="$*"
    output="${opt_o}.n"
    
    #   find a reasonable Awk
    awk=''
    paths=`echo $PATH |\
           sed -e 's%/*:%:%g' -e 's%/$%%' \
               -e 's/^:/.:/' -e 's/::/:.:/g' -e 's/:$/:./' \
               -e 's/:/ /g'`
    for name in gawk nawk awk; do
        for path in $paths; do
            if [ -r "$path/$name" ]; then
                awk="$path/$name"
                break
            fi
        done
        if [ ".$awk" != . ]; then
            break
        fi
    done
    if [ ".$awk" = . ]; then
        echo "$msgprefix:Error: cannot find a reasonable Awk" 1>&2
        exit 1
    fi
    
    #   parse source file(s)
    if [ ".$opt_v" = .yes ]; then
        echo "Parsing:" | $awk '{ printf("%s", $0); }' 1>&2
    fi
    for src in $srcs; do
        if [ ".$opt_v" = .yes ]; then
            echo $src | $awk '{ printf(" %s", $0); }' 1>&2
        fi
        if [ ".$opt_f" = . ]; then
            inputcmd="cat $src"
        else
            inputcmd="sed $opt_f $src"
        fi
        $inputcmd |\
        $awk '
           BEGIN {
               ln    = 0;
               fln   = 0;
               level = 0;
               mode  = "";
               store = "";
           }
           {
               ln++;
           }
           /^#if.*/ {
               level++;
           }
           /^#if [a-zA-Z_][a-zA-Z0-9_]* *$/ {
               if ($2 == define) {
                   mode = "D";
                   printf("D:#line %d \"%s\"\n", ln, src);
                   next;
               }
           }
           /^#endif.*/ {
               level--;
               if (mode == "D" && level == 0) {
                   mode = "";
                   next;
               }
           }
           /^[a-zA-Z_][a-zA-Z0-9_].*;.*/ {
               if ($1 == class) {
                   printf("V:#line %d \"%s\"\n", ln, src);
                   printf("V:%s\n", $0);
                   printf("J:%s\n", $0);
                   next;
               }
           }
           /^[a-zA-Z_][a-zA-Z0-9_].*=.*/ {
               if ($1 == class) {
                   printf("V:#line %d \"%s\"\n", ln, src);
                   printf("V:%s\n", $0);
                   printf("J:%s\n", $0);
                   next;
               }
           }
           /^[a-zA-Z_][a-zA-Z0-9_]*/ {
               if ($1 == class) {
                   fln = ln;
                   store = $0;
                   mode = "F";
                   next;
               }
           }
           /^\{ *$/ {
               if (mode == "F") {
                   printf("F:#line %d \"%s\"\n", fln, src);
                   printf("F:%s;\n", store);
                   printf("I:%s;\n", store);
                   store = "";
                   mode = "";
                   next;
               }
           }
           {
               if (mode == "D")
                   printf("D:%s\n", $0);
               else if (mode == "F")
                   store = store " " $0;
           }
        ' "src=$src" "define=$opt_D" "class=$opt_C" >>$tmpfile
    done
    if [ ".$opt_v" = .yes ]; then
        echo "" 1>&2
    fi
    
    #   start generating output header
    echo "/* $opt_o -- autogenerated from $opt_t, DO NOT EDIT! */" >$output
    echo "#line 1 \"$opt_t\"" >>$output
    sed <$opt_t -e "1,/^${opt_M} *\$/p" -e 'd' |\
    sed -e "/^${opt_M} *\$/d" >>$output
    
    #   merge in the define blocks
    grep '^D:' $tmpfile | sed -e 's/^D://' >>$output
    
    #   generate standard prolog
    echo "#line 1 \"_ON_THE_FLY_\"" >>$output
    echo "" >>$output
    echo "/* make sure the scpp source extensions are skipped */" >>$output
    echo "#define $opt_D 0" >>$output
    echo "#define $opt_C /**/" >>$output
    
    #   generate namespace hiding for variables
    echo "" >>$output
    echo "/* move intern variables to hidden namespace */" >>$output
    grep '^J:' $tmpfile | sed >>$output \
        -e 's/^J://' \
        -e 's/  */ /g' \
        -e 's/^[^=;]*[ *]\([a-zA-Z0-9_]*\)\[\];.*$/#define \1 __\1/' \
        -e 's/^[^=;]*[ *]\([a-zA-Z0-9_]*\)\[\] =.*$/#define \1 __\1/' \
        -e 's/^[^=;]*[ *]\([a-zA-Z0-9_]*\);.*$/#define \1 __\1/' \
        -e 's/^[^=;]*[ *]\([a-zA-Z0-9_]*\) =.*$/#define \1 __\1/'
    
    #   generate namespace hiding for functions
    echo "" >>$output
    echo "/* move intern functions to hidden namespace */" >>$output
    grep '^I:' $tmpfile | sed >>$output \
        -e 's/^I://' \
        -e 's/\([ (]\) */\1/g' \
        -e 's/ *\([),]\)/\1/g' \
        -e 's/^[^(]*[ *]\([a-zA-Z0-9_]*\)(.*$/#define \1 __\1/'
    
    #   generate prototypes for variables
    echo "" >>$output
    echo "/* prototypes for intern variables */" >>$output
    grep '^V:' $tmpfile | sed >>$output \
        -e 's/^V://' \
        -e 's/  */ /g' \
        -e 's/^\([^=;]*[ *][a-zA-Z0-9_]*\[\]\);.*$/\1;/' \
        -e 's/^\([^=;]*[ *][a-zA-Z0-9_]*\[\]\) =.*$/\1;/' \
        -e 's/^\([^=;]*[ *][a-zA-Z0-9_]*\);.*$/\1;/' \
        -e 's/^\([^=;]*[ *][a-zA-Z0-9_]*\) =.*$/\1;/' \
        -e 's/ ;/;/g' \
        -e "s/^$opt_C /extern /"
    
    #   generate prototypes for functions
    echo "" >>$output
    echo "/* prototypes for intern functions */" >>$output
    grep '^F:' $tmpfile | sed >>$output \
        -e 's/^F://' \
        -e 's/\([ (]\) */\1/g' \
        -e 's/ *\([),]\)/\1/g' \
        -e 's/\([* ]\)[a-zA-Z0-9_]*,/\1,/g' \
        -e 's/\([* ]\)[a-zA-Z0-9_]*);/\1);/g' \
        -e 's/(\*[a-zA-Z0-9_]*)(/(*)(/g' \
        -e 's/\([ (]\) */\1/g' \
        -e 's/ *\([),]\)/\1/g' \
        -e "s/^$opt_C /extern /"
    
    #   finish generating output header
    n=`(echo ''; sed <$opt_t -e "1,/^${opt_M} *\$/p" -e 'd') |\
       wc -l | sed -e 's;^ *\([0-9]*\) *$;\1;'`
    echo "#line $n \"$opt_t\"" >>$output
    sed <$opt_t -e "/^${opt_M} *\$/,\$p" -e 'd' |\
    sed -e "/^${opt_M} *\$/d" >>$output
    
    #   create final output file
    if [ -f $opt_o ]; then
        if [ ".$opt_p" = .yes ]; then
            grep -v '^#line' $opt_o  >$tmpfile.o
            grep -v '^#line' $output >$tmpfile.n
            out_old="$tmpfile.o"
            out_new="$tmpfile.n"
        else
            out_old="$opt_o"
            out_new="$output"
        fi
        if cmp -s $out_old $out_new; then
            :
        else
            cp $output $opt_o
        fi
    else
        cp $output $opt_o
    fi
    rm -f $output
    rm -f $tmpfile $tmpfile.* >/dev/null 2>&1
    ;;

version )
    ##
    ##  version -- Maintain a version information file
    ##  Copyright (c) 1994-2000 Ralf S. Engelschall <rse@engelschall.com>
    ##  Originally written for ePerl, rewritten from scratch for shtool
    ##
    
    file="$1"
    
    #   determine prefix and name
    name="$opt_n"
    prefix="$opt_p"
    
    #   determine current version
    triple="$opt_s"
    if [ ".$triple" != . ]; then
        #   use given triple
        if [ ".`echo $triple | grep '[0-9]*.[0-9]*[sabp.][0-9]*'`" = . ]; then
            echo "$msgprefix:Error: invalid argument to option \`-s': \`$opt_s'" 1>&2
            exit 1
        fi
        eval `echo $triple |\
              sed -e 's%\([0-9]*\)\.\([0-9]*\)\([sabp.]\)\([0-9]*\).*%\
              ver="\1";rev="\2";typ="\3";lev="\4"%'`
        tim=calc
    elif [ -r $file ]; then
        #   determine triple from given file
        eval `grep 'Version [0-9]*.[0-9]*[sabp.][0-9]* ([0-9]*-[a-zA-Z]*-[0-9]*)' $file |\
              head -1 | sed -e 's%.*Version \([0-9]*\)\.\([0-9]*\)\([sabp.]\)\([0-9]*\) (\([0-9]*-[a-zA-Z]*-[0-9]*\)).*%\
              ver="\1";rev="\2";typ="\3";lev="\4";tim="\5"%'`
    else
        #   intialise to first version
        ver=0
        rev=1
        typ=.
        lev=0
        tim=calc
    fi
    
    #   determine new version in batch
    if [ ".$opt_i" != . ]; then
        case $opt_i in
            v ) ver=`expr $ver + 1`
                rev=0
                lev=0
                ;;
            r ) rev=`expr $rev + 1`
                lev=0
                ;;
            l ) lev=`expr $lev + 1`
                ;;
            * ) echo "$msgprefix:Error: invalid argument to option \`-i': \`$opt_i'" 1>&2
                exit 1
                ;;
        esac
        tim=calc
    fi
    
    #   determine new version interactively
    if [ ".$opt_e" = .yes ]; then
        echo "old version: ${ver}.${rev}${typ}${lev}"
        while [ 1 ]; do
            echo dummy | awk '{ printf("new version: "); }'
            read triple
            case $triple in
                [0-9]*.[0-9]*[sabp.][0-9]* ) 
                    ;;
                * ) echo "$msgprefix:Error: invalid version string entered: \`$triple'" 1>&2
                    continue
                    ;;
            esac
            break
        done
        eval `echo $triple |\
              sed -e 's%^\([0-9]*\)\.\([0-9]*\)\([sabp.]\)\([0-9]*\)$%\
              ver="\1";rev="\2";typ="\3";lev="\4"%'`
        tim=calc
    fi
    
    #   determine hexadecimal and libtool value of version
    case $typ in
        a     ) typnum=0;  levnum=$lev ;;
        b     ) typnum=1;  levnum=$lev ;;
        p | . ) typnum=2;  levnum=$lev ;;
        s     ) typnum=15; levnum=255  ;; # snapshots are special
    esac
    hex=`echo "$ver:$rev:$typnum:$levnum" |\
         awk -F: '{ printf("0x%X%02X%1X%02X", $1, $2, $3, $4); }'`
    ltv=`echo "$ver:$rev:$typnum:$levnum" |\
         awk -F: '{ printf("%d:%d", $1*10 + $2, $3*10 + $4); }'`
    
    #   determine date
    if [ ".$tim" = .calc ]; then
        day=`date '+%d'`
        month=`date '+%m'`
        year=`date '+%Y' 2>/dev/null`
        if [ ".$time_year" = . ]; then
            year=`date '+%y'`
            case $year in
                [5-9][0-9]) year="19$year" ;;
                [0-4][0-9]) year="20$year" ;;
            esac
        fi
        case $month in
            1|01) month='Jan' ;;
            2|02) month='Feb' ;;
            3|03) month='Mar' ;;
            4|04) month='Apr' ;;
            5|05) month='May' ;;
            6|06) month='Jun' ;;
            7|07) month='Jul' ;;
            8|08) month='Aug' ;;
            9|09) month='Sep' ;;
              10) month='Oct' ;;
              11) month='Nov' ;;
              12) month='Dec' ;;
        esac
        tim="${day}-${month}-${year}"
    fi
    
    #   perform result actions
    mode=show
    if [ ".$opt_i" != . ]; then
        mode=edit
    elif [ ".$opt_e" = .yes ]; then
        mode=edit
    elif [ ".$opt_s" != . ]; then
        mode=edit
    fi
    if [ ".$mode" = .show ]; then
        #   just display the current version
        case $opt_d in
            short )
                echo "${ver}.${rev}${typ}${lev}"
                ;;
            long )
                echo "${ver}.${rev}${typ}${lev} ($tim)"
                ;;
            libtool )
                echo "${ltv}"
                ;;
            hex )
                echo "${hex}"
                ;;
            * ) echo "$msgprefix:Error: invalid argument to option \`-d': \`$opt_d'" 1>&2
                exit 1
                ;;
        esac
    else 
        #   update the version file
    
        #   pre-generate various strings
        triple="${ver}.${rev}${typ}${lev}"
        vHex="$hex"
        vShort="${triple}"
        vLong="${triple} (${tim})"
        vTeX="This is ${name}, Version ${triple} (${tim})"
        vGNU="${name} ${triple} (${tim})"
        vWeb="${name}/${triple}"
        vSCCS="@(#)${name} ${triple} (${tim})"
        vRCS="\$Id${name} ${triple} (${tim}) \$"
    
        #   determine string out of filename
        #   (do NOT try to optimize this in any way because of portability)
        filestr=`echo $file |\
                 tr 'abcdefghijklmnopqrstuvwxyz./%+' \
                    'ABCDEFGHIJKLMNOPQRSTUVWXYZ____' | sed -e 's/-/_/g'`
    
        #   generate uppercase prefix
        prefixupper=`echo $prefix |\
                     tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
        
        #   create the version file according the the selected language
        echo "new version: ${vLong}"
    
        cp /dev/null $file
        case $opt_l in
            txt )
                echo >>$file ""
                echo >>$file "  ${file} -- Version Information for ${name} (syntax: Text)"
                echo >>$file "  [automatically generated and maintained by GNU shtool]"
                echo >>$file ""
                echo >>$file "  $vTeX"
                echo >>$file ""
                ;;
            c )
                echo >>$file "/*"
                echo >>$file "**  ${file} -- Version Information for ${name} (syntax: C/C++)"
                echo >>$file "**  [automatically generated and maintained by GNU shtool]"
                echo >>$file "*/"
                echo >>$file ""
                echo >>$file "#ifdef _${filestr}_AS_HEADER_"
                echo >>$file ""
                echo >>$file "#ifndef _${filestr}_"
                echo >>$file "#define _${filestr}_"
                echo >>$file ""
                echo >>$file "#define ${prefixupper}VERSION ${vHex}"
                echo >>$file ""
                echo >>$file "typedef struct {"
                echo >>$file "    const int   v_hex;"
                echo >>$file "    const char *v_short;"
                echo >>$file "    const char *v_long;"
                echo >>$file "    const char *v_tex;"
                echo >>$file "    const char *v_gnu;"
                echo >>$file "    const char *v_web;"
                echo >>$file "    const char *v_sccs;"
                echo >>$file "    const char *v_rcs;"
                echo >>$file "} ${prefix}version_t;"
                echo >>$file ""
                echo >>$file "extern ${prefix}version_t ${prefix}version;"
                echo >>$file ""
                echo >>$file "#endif /* _${filestr}_ */"
                echo >>$file ""
                echo >>$file "#else /* _${filestr}_AS_HEADER_ */"
                echo >>$file ""
                echo >>$file "#define _${filestr}_AS_HEADER_"
                echo >>$file "#include \"${file}\""
                echo >>$file "#undef  _${filestr}_AS_HEADER_"
                echo >>$file ""
                echo >>$file "${prefix}version_t ${prefix}version = {"
                echo >>$file "    ${vHex},"
                echo >>$file "    \"${vShort}\","
                echo >>$file "    \"${vLong}\","
                echo >>$file "    \"${vTeX}\","
                echo >>$file "    \"${vGNU}\","
                echo >>$file "    \"${vWeb}\","
                echo >>$file "    \"${vSCCS}\","
                echo >>$file "    \"${vRCS}\""
                echo >>$file "};"
                echo >>$file ""
                echo >>$file "#endif /* _${filestr}_AS_HEADER_ */"
                echo >>$file ""
                ;;
            perl )
                echo >>$file "##"
                echo >>$file "##  ${file} -- Version Information for ${name} (syntax: Perl)"
                echo >>$file "##  [automatically generated and maintained by GNU shtool]"
                echo >>$file "##"
                echo >>$file ""
                echo >>$file "my \$${prefix}version = {"
                echo >>$file "    'v_hex'   => ${vHex},"
                echo >>$file "    'v_short' => \"${vShort}\","
                echo >>$file "    'v_long'  => \"${vLong}\","
                echo >>$file "    'v_tex'   => \"${vTeX}\","
                echo >>$file "    'v_gnu'   => \"${vGNU}\","
                echo >>$file "    'v_web'   => \"${vWeb}\","
                echo >>$file "    'v_sccs'  => \"${vSCCS}\","
                echo >>$file "    'v_rcs'   => \"\\${vRCS}/\""
                echo >>$file "};"
                echo >>$file ""
                echo >>$file "1;"
                echo >>$file ""
                ;;
            * ) echo "$msgprefix:Error: invalid argument to option \`-l': \`$opt_l'" 1>&2
                exit 1
                ;;
        esac
    fi
    ;;

esac

exit 0

##EOF##