source: vendor/bash/3.1/examples/functions/kshenv

#
# .kshenv -- functions and aliases to provide the beginnings of a ksh 
#            environment for bash.
#
# Chet Ramey
# chet@ins.CWRU.Edu
#
#
# These are definitions for the ksh compiled-in `exported aliases'.  There
# are others, but we already have substitutes for them: "history", "type",
# and "hash".
#
alias r="fc -s"
alias functions="typeset -f"
alias integer="typeset -i"
alias nohup="nohup "
alias command="command "
alias stop="kill -s STOP"
alias redirect="command exec"
alias hist="fc"

#
# An almost-ksh compatible `whence' command.  This is as hairy as it is 
# because of the desire to exactly mimic ksh (whose behavior was determined
# empirically).
# 
# This depends somewhat on knowing the format of the output of the bash
# `builtin type' command.
#

whence()
{
        local vflag pflag fflag defarg c
        local path

        vflag= aflag= pflag= fflag=
        path=
        if [ "$#" = "0" ] ; then
                echo "whence: usage: whence [-afpv] name..." >&2
                return 2
        fi

        OPTIND=1
        while getopts "avfp" c
        do
                case "$c" in
                a) defarg=-a ;;
                f) fflag=1 ;;   # no-op
                p) pflag=1 ;;
                v) vflag=1 ;;
                ?) echo "whence: $1: unknown option" >&2
                   echo "whence: usage: whence [-afpv] name..." >&2
                   return 2 ;;
                esac
        done

        shift $(( $OPTIND - 1 ))

        if [ "$#" = "0" ] ; then
                echo "whence: usage: whence [-afpv] name..." >&2
                return 2
        fi

        for cmd
        do
                if [ "$vflag" ]  ; then
                        if [ -z "$defarg" ]; then
                                builtin type $cmd | sed 1q
                        else
                                if builtin type $defarg -t $cmd | grep 'function$' >/dev/null 2>&1; then
                                        # HAIRY awk script to suppress
                                        # printing of function body -- could
                                        # do it with sed, but I don't have
                                        # that kind of time
                                        builtin type $defarg $cmd | awk '
BEGIN {printit = 1;}
$1 == "'$cmd'" && $2 == "()" {printit=0; next; }
/^}$/ { if (printit == 0) printit=1 ; else print $0; next ; }
/.*/ { if (printit) print $0; }'
                                else
                                        builtin type $defarg $cmd
                                fi
                        fi
                else
                        path=$(builtin type $defarg -p $cmd)
                        if [ "$path" ] ; then
                                echo $path
                        else
                                case "$cmd" in
                                /*) echo "" ;;
                                 *) case "$(builtin type -t $cmd)" in
                                    "") echo "" ;;
                                    *) echo "$cmd" ;;
                                    esac
                                    ;;
                                esac
                        fi
                fi
        done
        return 0
}

#
# For real ksh homeboy fanatics, redefine the `type' builtin with a ksh
# version.
#
#type()
#{
#       whence -v "$*"
#}

#
# ksh-like `cd': cd [-LP] [dir [change]]
#
cd()
{
        OPTIND=1
        while getopts "LP" opt
        do
                case $opt in
                L|P)    CDOPTS="$CDOPTS -$opt" ;;
                *)      echo "$FUNCNAME: usage: $FUNCNAME [-LP] [dir] [change]" >&2
                        return 2;;
                esac
        done

        shift $(( $OPTIND - 1 ))

        case $# in
        0)      builtin cd $CDOPTS "$HOME" ;;
        1)      builtin cd $CDOPTS "$@" ;;
        2)      old="$1" new="$2"
                case "$PWD" in
                *$old*) ;;
                *)       echo "${0##*/}: $FUNCNAME: bad substitution" >&2 ; return 1 ;;
                esac

                dir=${PWD//$old/$new}

                builtin cd $CDOPTS "$dir" && echo "$PWD"

                ;;
        *)      echo "${0##*/}: $FUNCNAME: usage: $FUNCNAME [-LP] [dir] [change]" >&2
                return 2 ;;
        esac
}

#
# ksh print emulation
#
#       print [-Rnprsu[n]] [-f format] [arg ...]
#
#       -       end of options
#       -R      BSD-style -- only accept -n, no escapes
#       -n      do not add trailing newline
#       -p      no-op (no coprocesses)
#       -r      no escapes
#       -s      print to the history file
#       -u n    redirect output to fd n
#       -f format       printf "$format" "$@"
#

print()
{
        local eflag=-e
        local nflag= fflag= c
        local fd=1

        OPTIND=1
        while getopts "fRnprsu:" c
        do
                case $c in
                R)      eflag= ;;
                r)      eflag= ;;
                n)      nflag=-n ;;
                s)      sflag=y ;;
                f)      fflag=y ;;
                u)      fd=$OPTARG ;;
                p)      ;;
                esac
        done
        shift $(( $OPTIND - 1 ))

        if [ -n "$fflag" ]; then
                builtin printf "$@" >&$fd
                return
        fi

        case "$sflag" in
        y)      builtin history -s "$*" ;;
        *)      builtin echo $eflag $nflag "$@" >&$fd
        esac
}

# substring function
# this function should be equivalent to the substring built-in which was
# eliminated after the 06/29/84 version
substring ()
{
        local lpat flag str     #local variables
        set -f
        case $1 in
        -l|-L)
                flag=$1
                lpat=$2
                shift 2
                ;;
        esac
        # test for too few or too many arguments
        if [ x"$1" = x ] || [ $# -gt 2 ]; then
                print -u2 'substring: bad argument count'
                return 1
        fi
        str=$1
        if [ x"$flag" = x-l ]; then             #substring -l lpat
                str=${str#$lpat}
        elif [ x"$flag" = x-L ]; then
                str=${str##$lpat}               #substring -L lpat
        fi

        if [ x"$2" != x ]; then
                echo ${str%$2}
        else
                echo $str
        fi

        return 0
}