#
# .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
}
