Imported from ../bash-1.14.7.tar.gz.

examples/alias-conv.sh

@@ -0,0 +1,22 @@
+#! /bin/sh
+#
+# Convert Csh aliases to Bash aliases.  Adapted from a similar program
+# supplied with zsh.
+#
+# This is a quick script to convert csh aliases to Bash aliases/functions.
+# Pipe the output of csh's alias command through this; it will generate
+# a series of alias/function definitions on stdout, suitable for
+# processing by bash.
+#
+# This is not perfect, but it gets most common aliases; it should manage to
+# cut down a lot of the busy work.
+#
+sed -e 's/	(\(.*\))/	\1/' >/tmp/cz$$.1
+grep ! /tmp/cz$$.1 >/tmp/cz$$.2
+grep -v ! /tmp/cz$$.1 >/tmp/cz$$.3
+sed -e "s/'/'"\\\\"''"/g -e 's/^\([^	]*\)	\(.*\)$/alias \1='"'\2'/" \
+	/tmp/cz$$.3
+sed -e 's/![:#]*/$/g' -e 's/^\([^	]*\)	\(.*\)$/\1 () { \2 }/' /tmp/cz$$.2
+rm /tmp/cz$$.?
+
+exit 0

examples/functions/autoload

@@ -0,0 +1,103 @@
+#
+# An almost ksh-compatible `autoload'.  A function declared as `autoload' will
+# be read in from a file the same name as the function found by searching the
+# $FPATH (which works the same as $PATH), then that definition will be run.
+#
+# To do this without source support, we define a dummy function that, when
+# executed, will load the file (thereby re-defining the function), then 
+# execute that newly-redefined function with the original arguments.
+#
+# It's not identical to ksh because ksh apparently does lazy evaluation
+# and looks for the file to load from only when the function is referenced.
+# This one requires that the file exist when the function is declared as
+# `autoload'.
+#
+# usage: autoload func [func...]
+#
+# The first cut of this was by Bill Trost, trost@reed.bitnet
+#
+# Chet Ramey
+# chet@ins.CWRU.Edu
+
+#
+# Declare a function ($1) to be autoloaded from a file ($2) when it is first
+# called.  This defines a `temporary' function that will `.' the file 
+# containg the real function definition, then execute that new definition with
+# the arguments given to this `fake' function.  The autoload function defined
+# by the file and the file itself *must* be named identically.
+#
+
+aload()
+{
+	eval $1 '() {  . '$2' ; '$1' "$@" ; return $?; }'
+}
+
+#
+# Search $FPATH for a file the same name as the function given as $1, and
+# autoload the function from that file.  There is no default $FPATH.
+#
+
+autoload()
+{
+	#
+	# Save the list of functions; we're going to blow away the arguments
+	# in a second.  If any of the names contain white space, TFB.
+	#
+
+	local args="$*"
+
+	#
+	# This should, I think, list the functions marked as autoload and not
+	# yet defined, but we don't have enough information to do that here.
+	#
+	if [ $# -eq 0 ] ; then
+		echo "usage: autoload function [function...]"
+		return 1
+	fi
+
+	#
+	# If there is no $FPATH, there is no work to be done
+	#
+
+	if [ -z "$FPATH" ] ; then
+		echo autoload: FPATH not set
+		return 1
+	fi
+
+	#
+	# This treats FPATH exactly like PATH: a null field anywhere in the
+	# FPATH is treated the same as the current directory.
+	#
+	# The path splitting command is taken from Kernighan and Pike
+	#
+
+	fp=$(echo $FPATH | sed 's/^:/.:/
+				s/::/:.:/g
+				s/:$/:./
+				s/:/ /g')
+
+	for FUNC in $args ; do
+		#
+		# We're blowing away the arguments to autoload here...
+		# We have to; there are no arrays.
+		#
+		set $fp
+
+		while [ $# -ne 0 ] ; do
+			if [ -f $1/$FUNC ] ; then
+				break			# found it! 
+			fi
+			shift
+		done
+
+		if [ $# -eq 0 ] ; then
+			echo "$FUNC: autoload function not found"
+			continue
+		fi
+
+#		echo auto-loading $FUNC from $1/$FUNC
+		aload $FUNC $1/$FUNC
+	done
+
+	return 0
+}

examples/functions/basename

@@ -0,0 +1,23 @@
+# Date: Fri, 11 Oct 91 11:22:36 edt
+# From: friedman@gnu.ai.mit.edu
+# To: bfox@gnu.ai.mit.edu
+
+# A replacement for basename(1).  Not all the systems I use have this
+# program.  Usage: basename [path] {extension}
+function basename ()
+{
+ local path="$1"
+ local suffix="$2"
+ local tpath="${path%/}"
+
+    # Strip trailing '/' characters from path (unusual that this should
+    # ever occur, but basename(1) seems to deal with it.)
+    while [ "${tpath}" != "${path}" ]; do
+       tpath="${path}"
+       path="${tpath%/}"
+    done
+
+    path="${path##*/}"       # Strip off pathname
+    echo ${path%${suffix}}   # Also strip off extension, if any.
+}
+

examples/functions/csh-compat

@@ -0,0 +1,36 @@
+# C-shell compatabilty package.
+# setenv VAR VALUE
+function setenv () {
+  export $1="$2"
+}
+
+function unsetenv () {
+  unset $1
+}
+
+function alias () {
+  local name=$1
+  shift
+  local value="$*"
+
+  if [ "$name" = "" ]; then
+    builtin alias
+  elif [ "$value" = "" ]; then
+    builtin alias $name
+  else
+    builtin alias $name="$value"
+  fi
+}
+
+# Can't write foreach yet.  Need pattern matching, and a few extras.
+function foreach () {
+echo 'Can'\''t do `foreach'\'' yet.  Type "help for".'
+}
+
+# Make this work like csh's.  Special case "term" and "path".
+#set () {
+#}
+
+chdir () {
+  builtin cd $*
+ }

examples/functions/dirfuncs

@@ -0,0 +1,142 @@
+#
+# Directory manipulation functions from the book 'The Korn Shell'
+# Modified for use with bash Mon Apr 18 08:37 1994 by
+# Ken Konecki (kenk@wfg.com)
+#
+# Modified by Chet Ramey
+#
+# This could stand to have calls to `select' added back in
+# 
+
+alias integer="declare -i"
+
+integer  _push_max=${CDSTACK-31} _push_top=${CDSTACK-31}
+
+unalias cd
+# alias cd=_cd
+
+# Display directory stack -- $HOME display as ~
+dirs()
+{
+    dir="${PWD#$HOME/}" 
+    case $dir in
+    $HOME) dir=\~ ;;
+    /*) ;;
+    *) dir=\~/$dir ;;
+    esac
+
+    integer i=_push_top
+    integer n=1
+
+    echo "$n) $dir"
+    while let "i < $_push_max"
+    do
+       n=n+1
+       eval "echo \$n\) \$_push_stack_$i"
+       i=i+1
+    done
+}
+
+# Change directory and put directory on front of stack
+cd()
+{
+    typeset dir=
+    integer n=0 type=4 i
+    case $1 in
+    -|-1|2) # cd -
+	n=_push_top type=1
+	;;
+    -[1-9]|-[1-9][0-9]) # cd -n
+	n=_push_top+${1#-}-1 type=2
+	;;
+
+    1) # keep present directory
+	echo "$PWD"
+	return
+	;;
+
+    [2-9]|[1-9][0-9]) # cd n
+	n=_push_top+${1}-2 type=2
+	;;
+
+    *)
+	if let "_push_top <= 0"; then
+	    type=3 n=_push_max
+	fi
+	;;
+    esac
+
+    if let "type < 3"; then
+	if let "n >= _push_max"; then
+	    echo cd: Directory stack not that deep
+	    return 1
+	else
+	    eval dir=\${_push_stack_$n}
+	fi
+    fi
+
+    case $dir in
+    ~*) dir=$HOME${dir#\~} ;;
+    esac
+
+    cd2 ${dir:-$@} > /dev/null || return 1
+    dir=${OLDPWD#$HOME/}
+    case $dir in
+    $HOME)	dir=\~ ;;
+    /*) 	;;
+    *) 		dir=\~/$dir ;;
+    esac
+
+    case $type in
+    1) # swap first two elements
+	eval _push_stack_$_push_top=\$dir ;;
+
+    2|3) # put $dir on top and shift down by one until top
+	i=_push_top
+	unset _dirlist
+	while let "i < $_push_max" ; do
+	    eval _dirlist=\"\$_dirlist \$_push_stack_$i\"
+	    i=i+1
+	done
+
+	i=_push_top
+	for dir in "$dir" ${_dirlist} ; do
+	    let "i > n" && break
+	    eval _push_stack_$i=\$dir
+	    i=i+1
+	done
+	;;
+    4) # push name
+	_push_top=_push_top-1;
+	eval _push_stack_$_push_top=\$dir
+	;;
+    esac
+
+    echo "$PWD"
+
+}
+
+# Menu-driven change directory command
+function mcd
+{
+    dirs
+    echo -n "Select by number or enter a name: "
+    read
+    cd $REPLY
+}
+
+
+# Emulate ksh cd substitution
+cd2()
+{
+    case "$#" in
+    0)	builtin cd "$HOME" ;;
+    1)  builtin cd "$1" ;;
+    2)  newDir=$(echo $PWD | sed -e "s:$1:$2:g")
+	case "$newDir" in
+	$PWD)	echo "bash:: cd: bad substitution" >&2 ; return 1 ;;
+	*)	builtin cd "$newDir" ;;
+	esac ;;
+    *)  echo "bash: cd: wrong arg count" 1>&2 ; return 1 ;;
+    esac
+} 	

examples/functions/dirname

@@ -0,0 +1,21 @@
+# Date: Fri, 11 Oct 91 11:22:36 edt
+# From: friedman@gnu.ai.mit.edu
+# To: bfox@gnu.ai.mit.edu
+
+# A replacement for dirname(1).  This one appears less often on some
+# systems I use than basename(1), and I really depend on it for some
+# things.  Usage: dirname [path]
+function dirname ()
+{
+ local dir="$1"
+ local tdir="${dir%/}"
+
+    # Strip trailing '/' characters from dir (unusual that this should
+    # ever occur, but dirname(1) seems to deal with it.)
+    while [ "${tdir}" != "${dir}" ]; do
+       tdir="${dir}"
+       dir="${tdir%/}"
+    done
+
+    echo "${dir%/*}"
+}

examples/functions/exitstat

@@ -0,0 +1,22 @@
+# Contributed by Noah Friedman and Roland McGrath.
+
+# To be run by the PROMPT_COMMAND variable, so that one can see what
+# the exit status of processes are.
+
+function check_exit_status ()
+{
+ local status="$?"
+ local signal=""
+
+    if [ ${status} -ne 0 -a ${status} != 128 ]; then
+       # If process exited by a signal, determine name of signal.
+       if [ ${status} -gt 128 ]; then
+          signal="$(builtin kill -l $[${status} - 128] 2>/dev/null)"
+	  if [ "$signal" ]; then signal="($signal)"; fi
+       fi
+       echo "[Exit ${status} ${signal}]" 1>&2
+    fi
+    return 0
+}
+
+PROMPT_COMMAND=check_exit_status

examples/functions/external

@@ -0,0 +1,50 @@
+# Contributed by Noah Friedman.
+
+# To avoid using a function in bash, you can use the `builtin' or
+# `command' builtins, but neither guarantees that you use an external
+# program instead of a bash builtin if there's a builtin by that name.  So
+# this function can be used like `command' except that it guarantees the
+# program is external by first disabling any builtin by that name.  After
+# the command is done executing, the state of the builtin is restored. 
+function external ()
+{
+ local state=""
+ local exit_status
+  
+    if builtin_p "$1"; then
+       state="builtin"
+       enable -n "$1"
+    fi
+
+    command "$@"
+    exit_status=$?
+
+    if [ "$state" = "builtin" ]; then
+       enable "$1"
+    fi
+
+    return ${exit_status}
+}
+
+# What is does is tell you if a particular keyword is currently enabled as
+# a shell builtin.  It does NOT tell you if invoking that keyword will
+# necessarily run the builtin.  For that, do something like
+#
+#       test "$(builtin type -type [keyword])" = "builtin"
+#
+# Note also, that disabling a builtin with "enable -n" will make builtin_p
+# return false, since the builtin is no longer available.
+function builtin_p ()
+{
+ local word
+
+    set $(builtin type -all -type "$1")
+
+    for word in "$@" ; do
+       if [ "${word}" = "builtin" ]; then
+          return 0
+       fi
+    done
+
+    return 1
+}

examples/functions/fact

@@ -0,0 +1,13 @@
+# Who said shells can't use recursion?  Here is a factorial function.
+# You call it with a number as an argument, and it returns the factorial
+# of that number.
+
+fact ()
+{
+    local num=$1;
+    if [ "$num" = 1 ] ; then
+        echo 1
+        return ;
+    fi;
+    echo $[ $num * $(fact $[ $num - 1 ])]
+}

examples/functions/fstty

@@ -0,0 +1,59 @@
+#
+# A function that works as a front end for both stty and the `bind'
+# builtin, so the tty driver and readline see the same changes
+#
+
+#
+# Convert between the stty ^H control character form and the readline \C-H
+# form
+#
+cvt()
+{
+	echo "$@" | cat -v | sed 's/\^/\\C-/'
+}
+
+#
+# stty front-end.  Parses the argument list and creates two command strings,
+# one for stty, another for bind.
+#
+fstty()
+{
+	local	cmd="" bargs=""
+	local	e
+
+	while [ $# -gt 0 ]
+	do
+		case "$1" in
+		-a)	cmd="$cmd everything"
+			;;
+		erase)	shift;
+			e=$(cvt "$1")
+			cmd="$cmd erase $1"
+			bargs="$bargs '\"$e\": backward-delete-char'"
+			;;
+		kill)	shift
+			e=$(cvt "$1")
+			cmd="$cmd kill $1"
+			bargs="$bargs '\"$e\": unix-line-discard'"
+			;;
+		werase)	shift;
+			e=$(cvt "$1")
+			cmd="$cmd erase $1"
+			bargs="$bargs '\"$e\": backward-kill-word'"
+			;;
+		lnext)	shift;
+			e=$(cvt "$1")
+			cmd="$cmd erase $1"
+			bargs="$bargs '\"$e\": quoted-insert'"
+			;;
+		*)	cmd="$cmd $1"
+			;;
+		esac
+		shift
+	done
+
+	command stty $cmd
+	if [ -n "$bargs" ]; then
+		builtin bind $bargs
+	fi
+}

examples/functions/func

@@ -0,0 +1,27 @@
+#
+# func -- print out definitions for functions named by arguments
+#
+# usage: func name [name ...]
+#
+# Chet Ramey
+# chet@ins.CWRU.Edu
+func()
+{
+	local status=0
+
+	if [ $# -eq 0 ] ; then
+		echo "usage: func name [name...]" 1>&2
+		return 1
+	fi
+
+	for f
+	do
+		if [ "$(builtin type -type $f)" != "function" ] ; then
+			echo "func: $f: not a function" 1>&2
+			status=1	# one failed
+			continue
+		fi
+		builtin type $f | sed 1d
+	done
+	return $status
+}

examples/functions/jj.bash

@@ -0,0 +1,12 @@
+jj ()
+{
+	p=$(jobs $1);
+	echo $p
+
+	case "$p" in
+	[*)	echo matches '[*'
+		;;
+	*)	echo not a match\?
+		;;
+	esac
+}

examples/functions/kshenv

@@ -0,0 +1,183 @@
+#
+# .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 -e -"
+alias functions="typeset -f"
+alias integer="typeset -i"
+alias nohup="nohup "
+alias true=":"
+alias false="let 0"
+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
+	local path
+
+	vflag=
+	path=
+	if [ "$#" = "0" ] ; then
+		echo "whence: argument expected"
+		return 1
+	fi
+	case "$1" in
+		-v) vflag=1
+		    shift 1
+		    ;;
+		-*) echo "whence: bad option: $1"
+		    return 1
+		    ;;
+		 *) ;;
+	esac
+
+	if [ "$#" = "0" ] ; then
+		echo "whence: bad argument count"
+		return 1
+	fi
+
+	for cmd
+	do
+		if [ "$vflag" ]	 ; then
+			echo $(builtin type $cmd | sed 1q)
+		else
+			path=$(builtin type -path $cmd)
+			if [ "$path" ] ; then
+				echo $path
+			else
+				case "$cmd" in
+					/*) echo ""
+					    ;;
+					 *) case "$(builtin type -type $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 "$*"
+#}
+
+cd()
+{
+	case $# in
+	0)	builtin cd "$HOME" ;;
+	1) 	builtin cd "$@" ;;
+	2)	old="$1"
+		new="$2"
+		dir=$(echo "$PWD" | sed "s:$old:$new:g")
+		case "$dir" in
+		"$PWD")	echo "bash: cd: bad substitution" >&2 ; return 1 ;;
+		*)	echo "$dir"
+			builtin cd "$dir"
+			;;
+		esac
+		;;
+	*)	echo "cd: wrong arg count" >&2 ; return 1 ;;
+	esac
+}
+
+#
+# ksh print emulation
+#
+#	print [-Rnprsu[n]] [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	no-op (print to the history file)
+#	-u n	redirect output to fd n
+#
+
+print()
+{
+	local eflag=-e
+	local nflag=
+	local fd=1
+
+	OPTIND=1
+	while getopts "Rnprsu:" c
+	do
+		case $c in
+		R)	eflag=
+			;;
+		r)	eflag=
+			;;
+		n)	nflag=-n
+			;;
+		u)	fd=$OPTARG
+			;;
+		p|s)	;;
+		esac
+	done
+	shift $[ $OPTIND - 1 ]
+
+	builtin echo $eflag $nflag "$@" >&$fd
+}
+
+# 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 -o $# -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
+}

examples/functions/manpage

@@ -0,0 +1,129 @@
+# Written from scratch by Tom Tromey (tromey@cns.caltech.edu)
+#
+# manpage -- find and print a manual page.
+# usage: manpage section name [printing]
+#
+function manpage ()
+{
+  local i h cmd zot sec
+  local num="$1"
+  local page="$2"
+  local printing="$3"
+  local mp
+
+  mp="${MANPATH:-/usr/man}"
+  if [ "$#" -lt 2 ]; then return 1; fi # should print usage
+  if [ "$num" != "" ]; then
+     sec="${num%%[a-zA-Z]*}"
+  else
+     sec='[168234571lnpo]'
+     num="$sec"
+  fi
+  for i in $(echo "$mp" | tr : ' '); do
+    if [ ! -d "$i" ]; then continue; fi
+    file="$i"/man"$sec"/"$page"."$num"*
+    set $file
+    file="$1"
+    if [ -f "$file" ]; then
+      zot=$(head -1 "$file")
+      cmd=${MANROFF:-"nroff -man - | col | cat -s"}
+      h=${zot##"'"'\"'}
+      if [ "$h" != "$zot" ]; then
+        while [ "$h" != "" ]; do
+          case "$h" in
+            *e) cmd="${MANEQN:-neqn} | $cmd";;
+            *r) cmd="refer | $cmd";;
+            *t) cmd="tbl | $cmd";;
+            *v) cmd="vgrind | $cmd";;
+            *) ;; # should print error
+          esac
+          h=${h%?}
+        done
+      fi
+      if [ "$printing" != "" ]; then
+        (cd "$i"; eval "$cmd") < "$file" | ${PAGER:-more}
+      else
+        (cd "$i"; eval "$cmd") < "$file" > /tmp/manpage-$$
+        ${PAGER:-more} /tmp/manpage-$$
+        rm -f /tmp/manpage-$$
+      fi
+      break
+    fi
+  done
+}
+
+function whatis_internal ()
+{
+  local j
+  for j in $(echo "$MANPATH" | tr : ' '); do
+    if [ -f "$j/whatis" ]; then
+      eval $2 -i -e "$1" $j/whatis
+    fi
+  done
+}
+
+function whatis ()
+{
+  local name=$(basename "$1")
+  whatis_internal "$name" "grep -w"
+}
+
+function apropos ()
+{
+  whatis_internal "$1" "fgrep"
+}
+
+# Note: "-" and "-t" together not supported.  This man could be
+# made a lot better, but it does everything I want.
+function man ()
+{
+  local PAGER printing mpath MANROFF num
+  mpath="${MANPATH:-/usr/man}"
+  while true; do
+    case "$1" in
+      -) PAGER=cat
+         printing= ;;
+      -t)
+         MANROFF=${TROFF:-"ptroff -man -t"}
+         PAGER="${TCAT:-lpr}"
+         printing=yes ;;
+      -M)
+         mpath="$2"
+         shift;;
+      *) break;;
+    esac
+    shift
+  done
+  local MANPATH="$mpath"
+  case "$1" in
+    -f | -k)
+      local g a
+      if [ "$1" = "-f" ]; then
+        g="grep -w"
+	a=$(basename "$2")
+      else
+	g=fgrep
+	a="$2"
+      fi
+      whatis_internal "$a" "$g"
+      ;;
+    [0-9npol] | [0-9][a-z]* | new | public | old | local)
+      if [ "$1" = "new" ]; then
+        num=n
+      elif [ "$1" = "public" ]; then
+        num=p
+      elif [ "$1" = "old" ]; then
+        num=o
+      elif [ "$1" = "local" ]; then
+        num=l
+      else
+	num="$1"
+      fi
+      shift
+      manpage "$num" "$1" "$printing"
+      ;;
+    *)
+      manpage "$num" "$1" "$printing"
+      ;;
+  esac
+}

examples/functions/notify.bash

@@ -0,0 +1,58 @@
+trap _notify CHLD
+NOTIFY_ALL=false
+unset NOTIFY_LIST
+unalias false
+
+false()
+{
+	return 1
+}
+
+_notify ()
+{
+	local i j
+	local newlist=
+
+	if $NOTIFY_ALL
+	then
+		return		# let bash take care of this itself
+	elif [ -z "$NOTIFY_LIST" ]; then
+		return
+	else
+		set -- $NOTIFY_LIST
+		for i in "$@"
+		do
+			j=$(jobs -n %$i)
+			if [ -n "$j" ]; then
+				echo "$j"
+				jobs -n %$i >/dev/null
+			else
+				newlist="newlist $i"
+			fi
+		done
+		NOTIFY_LIST="$newlist"
+	fi
+}
+
+notify ()
+{
+	local i j
+
+	if [ $# -eq 0 ]; then
+		NOTIFY_ALL=:
+		set -b
+		return
+	else
+		for i in "$@"
+		do
+			# turn a valid job spec into a job number
+			j=$(jobs $i)
+			case "$j" in
+			[*)	j=${j%%]*}
+				j=${j#[}
+				NOTIFY_LIST="$NOTIFY_LIST $j"
+				;;
+			esac
+		done
+	fi
+}

examples/functions/shcat

@@ -0,0 +1,7 @@
+shcat()
+{
+	while read line
+	do
+		echo "$line"
+	done
+}

examples/functions/substr

@@ -0,0 +1,79 @@
+#
+# substr -- a function to emulate the ancient ksh builtin
+#
+
+#
+# -l == shortest from left
+# -L == longest from left
+# -r == shortest from right (the default)
+# -R == longest from right
+
+substr()
+{
+	local flag pat str
+	local usage="usage: substr -lLrR pat string or substr string pat"
+
+	case "$1" in
+	-l | -L | -r | -R)
+		flag="$1"
+		pat="$2"
+		shift 2
+		;;
+	-*)
+		echo "substr: unknown option: $1"
+		echo "$usage"
+		return 1
+		;;
+	*)
+		flag="-r"
+		pat="$2"
+		;;
+	esac
+
+	if [ "$#" -eq 0 -o "$#" -gt 2 ] ; then
+		echo "substr: bad argument count"
+		return 2
+	fi
+
+	str="$1"
+
+	#
+	# We don't want -f, but we don't want to turn it back on if
+	# we didn't have it already
+	#
+	case "$-" in
+	"*f*")
+		;;
+	*)
+		fng=1
+		set -f
+		;;
+	esac
+
+	case "$flag" in
+	-l)
+		str="${str#$pat}"		# substr -l pat string
+		;;
+	-L)
+		str="${str##$pat}"		# substr -L pat string
+		;;
+	-r)
+		str="${str%$pat}"		# substr -r pat string
+		;;
+	-R)
+		str="${str%%$pat}"		# substr -R pat string
+		;;
+	*)
+		str="${str%$2}"			# substr string pat
+		;;
+	esac
+
+	echo "$str"
+
+	#
+	# If we had file name generation when we started, re-enable it
+	#
+	if [ "$fng" = "1" ] ; then
+		set +f
+	fi
+}

examples/functions/substr2

@@ -0,0 +1,81 @@
+#
+# substr -- a function to emulate the ancient ksh builtin
+#
+
+# -l == remove shortest from left
+# -L == remove longest from left
+# -r == remove shortest from right (the default)
+# -R == remove longest from right
+
+substr()
+{
+	local flag pat str
+	local usage="usage: substr -lLrR pat string or substr string pat"
+	local options="l:L:r:R:"
+
+	OPTIND=1
+	while getopts "$options" c
+	do
+		case "$c" in
+		l | L | r | R)
+			flag="-$c"
+			pat="$OPTARG"
+			;;
+		'?')
+			echo "$usage"
+			return 1
+			;;
+		esac
+	done
+
+	if [ "$OPTIND" -gt 1 ] ; then
+		shift $[ $OPTIND -1 ]
+	fi
+
+	if [ "$#" -eq 0 -o "$#" -gt 2 ] ; then
+		echo "substr: bad argument count"
+		return 2
+	fi
+
+	str="$1"
+
+        #
+        # We don't want -f, but we don't want to turn it back on if
+        # we didn't have it already
+        #
+        case "$-" in
+        "*f*")
+                ;;
+        *)
+                fng=1
+                set -f
+		;;
+        esac
+
+	case "$flag" in
+	-l)
+		str="${str#$pat}"		# substr -l pat string
+		;;
+	-L)
+		str="${str##$pat}"		# substr -L pat string
+		;;
+	-r)
+		str="${str%$pat}"		# substr -r pat string
+		;;
+	-R)
+		str="${str%%$pat}"		# substr -R pat string
+		;;
+	*)
+		str="${str%$2}"			# substr string pat
+		;;
+	esac
+
+	echo "$str"
+
+        #
+        # If we had file name generation when we started, re-enable it
+        #
+        if [ "$fng" = "1" ] ; then
+                set +f
+        fi
+}

examples/functions/term

@@ -0,0 +1,35 @@
+#
+# term -- a shell function to set the terminal type interactively or not.
+#
+
+term()
+{
+	local	t
+
+	if [ $# != 0 ] ; then
+		eval $(tset -sQ $1)
+	else				# interactive
+		if [ -z "$TERM" ] ; then
+			TERM="unknown"
+		fi
+
+		case "$TERM" in
+			network|dialup|unknown|lat)
+				TERM=unknown
+				;;
+			*)
+				eval $(tset -sQ)
+				;;
+		esac
+
+		while [ "$TERM" = "unknown" ] ; do
+			echo -n "Terminal type: "
+			read t
+			if [ -n "$t" ] ; then
+				eval $(tset -sQ $t)
+			fi
+		done
+	fi
+}
+
+		

examples/functions/whatis

@@ -0,0 +1,52 @@
+#
+# whatis -- and implementation of the 10th Edition Unix sh builtin `whatis'
+#	    command.
+#
+# usage: whatis arg [...]
+#
+# For each argument, whatis prints the associated value as a parameter,
+# builtin, function, alias, or executable file as appropriate.  In each
+# case, the value is printed in a form which would yield the same value
+# if typed as input to the shell itself.
+#
+
+whatis()
+{
+	local wusage='usage: whatis arg [arg...]'
+	local fail=0
+
+	if [ $# -eq 0 ] ; then
+		echo "$wusage"
+		return 1
+	fi
+
+	for arg
+	do
+		case $(builtin type -type $arg 2>/dev/null) in
+		"alias")
+			builtin alias "$arg"
+			;;
+		"function")
+			builtin type "$arg" | sed 1d
+			;;
+		"builtin")
+			echo builtin "$arg"
+			;;
+		"file")
+			builtin type -path "$arg"
+			;;
+		*)
+			# OK, we could have a variable, or we could have nada
+			if [ "$(eval echo \${$arg+set})" = "set" ] ; then
+				# It is a variable, and it is set
+				echo -n "$arg="
+				eval echo '\"'\$$arg'\"'
+			else
+				echo whatis: $arg: not found
+				fail=1
+			fi
+			;;
+		esac
+	done
+	return $fail
+}

examples/functions/whence

@@ -0,0 +1,59 @@
+#
+# An almost-ksh compatible `whence' command.  This is as hairy as it is 
+# because of the desire to exactly mimic ksh.
+# 
+# This depends somewhat on knowing the format of the output of the bash
+# `builtin type' command.
+#
+# Chet Ramey
+# chet@ins.CWRU.Edu
+#
+whence()
+{
+	local vflag= path=
+
+	if [ "$#" = "0" ] ; then
+		echo "whence: argument expected"
+		return 1
+	fi
+	case "$1" in
+		-v) vflag=1
+		    shift 1
+		    ;;
+		-*) echo "whence: bad option: $1"
+		    return 1
+		    ;;
+		 *) ;;
+	esac
+
+	if [ "$#" = "0" ] ; then
+		echo "whence: bad argument count"
+		return 1
+	fi
+
+	for cmd
+	do
+		if [ "$vflag" ]	 ; then
+			echo $(builtin type $cmd | sed 1q)
+		else
+			path=$(builtin type -path $cmd)
+			if [ "$path" ] ; then
+				echo $path
+			else
+				case "$cmd" in
+					/*) if [ -x "$cmd" ]; then
+						echo "$cmd"
+					    fi
+					    ;;
+					 *) case "$(builtin type -type $cmd)" in
+						"") ;;
+						 *) echo "$cmd"
+						    ;;
+					    esac
+					    ;;
+				esac
+			fi
+		fi
+	done
+	return 0
+}

examples/scripts/adventure.sh

@@ -0,0 +1,545 @@
+#!/bin/bash
+#	ash -- "Adventure shell"
+#	last edit:	86/04/21	D A Gwyn
+#	SCCS ID:	@(#)ash.sh	1.4
+
+OPATH=$PATH
+
+ask()
+{
+	echo -n "$@" '[y/n] '
+	read ans
+
+	case "$ans" in
+	y*|Y*)
+		return 0
+		;;
+	*)
+		return 1
+		;;
+	esac
+}
+	
+CAT=${PAGER:-more}
+
+ash_inst()
+{
+	cat <<- EOF
+
+	                Instructions for the Adventure shell
+
+	Welcome to the Adventure shell!  In this exploration of the UNIX file
+	system, I will act as your eyes and hands.  As you move around, I will
+	describe whatever is visible and will carry out your commands.  The
+	general form of a command is
+	        Verb Object Extra_stuff.
+	Most commands pay no attention to the "Extra_stuff", and many do not
+	need an "Object".  A typical command is
+	        get all
+	which picks up all files in the current "room" (directory).  You can
+	find out what you are carrying by typing the command
+	        inventory
+	The command "help" results in a full description of all commands that I
+	understand.  To quit the Adventure shell, type
+	        quit
+
+	There are UNIX monsters lurking in the background.  These are also
+	known as "commands with arguments".
+
+	Good luck!
+	EOF
+}
+
+ash_help()
+{
+echo "I understand the following commands (synonyms in parentheses):"
+echo ""
+
+echo "change OBJECT to NEW_NAME       changes the name of the object"
+echo "clone OBJECT as NEW_NAME        duplicates the object"
+echo "drop OBJECTS                    leaves the objects in the room"
+echo "enter (go) PASSAGE              takes the labeled passage"
+echo "examine OBJECTS                 describes the objects in detail"
+echo "feed OBJECT to MONSTER          stuffs the object into a UNIX monster"
+echo "get (take) OBJECTS              picks up the specified objects"
+echo "gripe (bug)                     report a problem with the Adventure shell"
+echo "help                            prints this summary"
+echo "inventory (i)                   tells what you are carrying"
+echo "kill (destroy) OBJECTS          destroys the objects"
+echo "look (l)                        describes the room, including hidden objects"
+echo "open (read) OBJECT              shows the contents of an object"
+echo "quit (exit)                     leaves the Adventure shell"
+echo "resurrect OBJECTS               attempts to restore dead objects"
+echo "steal OBJECT from MONSTER       obtains the object from a UNIX monster"
+echo "throw OBJECT at daemon          feeds the object to the printer daemon"
+echo "up                              takes the overhead passage"
+echo "wake MONSTER                    awakens a UNIX monster"
+echo "where (w)                       tells you where you are"
+echo "xyzzy                           moves you to your home"
+}
+	
+MAINT=chet@ins.cwru.edu
+
+PATH=/usr/ucb:/bin:/usr/bin:/usr/local/bin:.
+export PATH
+
+trap 'echo Ouch!' 2 3
+#trap '' 18			# disable Berkeley job control
+
+ash_lk(){ echo " $1 " | fgrep " $2 " >&- 2>&-; }
+ash_pr(){ echo $* | tr ' ' '\012' | pr -5 -t -w75 -l$[ ( $# + 4 ) / 5 ]; }
+ash_rm(){ echo " $1 " | sed -e "s/ $2 / /" -e 's/^ //' -e 's/ $//'; }
+
+cd
+LIM=.limbo			# $HOME/$LIM contains "destroyed" objects
+mkdir $LIM >&- 2>&-
+KNAP=.knapsack			# $HOME/$KNAP contains objects being "carried"
+if [ ! -d $KNAP ]
+then	mkdir $KNAP >&- 2>&-
+	if [ $? = 0 ]
+	then	echo 'You found a discarded empty knapsack.'
+	else	echo 'You have no knapsack to carry things in.'
+		exit 1
+	fi
+else	echo 'One moment while I peek in your old knapsack...'
+fi
+
+kn=`echo \`ls -a $KNAP | sed -e '/^\.$/d' -e '/^\.\.$/d'\``
+
+if ask 'Welcome to the Adventure shell!  Do you need instructions?'
+then
+	ash_inst
+	echo -n 'Type a newline to continue: '
+	read
+fi
+
+wiz=false
+cha=false
+prev=$LIM
+while :
+do	room=`pwd`
+	if [ $room != $prev ]
+	then	if [ $room = $HOME ]
+		then	echo 'You are in your own home.'
+		else	echo "You have entered $room."
+		fi
+		exs=
+		obs=
+		hexs=
+		hobs=
+		f=false
+		for i in `ls -a`
+		do	case $i in
+			.|..)	;;
+			.*)	if [ -f $i ]
+				then	hobs="$hobs $i"
+				elif [ -d $i ]
+				then	hexs="$hexs $i"
+				else	f=true
+				fi
+				;;
+			*)	if [ -f $i ]
+				then	obs="$obs $i"
+				elif [ -d $i ]
+				then	exs="$exs $i"
+				else	f=true
+				fi
+				;;
+			esac
+		done
+		if [ "$obs" ]
+		then	echo 'This room contains:'
+			ash_pr $obs
+		else	echo 'The room looks empty.'
+		fi
+		if [ "$exs" ]
+		then	echo 'There are exits labeled:'
+			ash_pr $exs
+			echo 'as well as a passage overhead.'
+		else	echo 'There is a passage overhead.'
+		fi
+		if sh -c $f
+		then	echo 'There are shadowy figures in the corner.'
+		fi
+		prev=$room
+	fi
+
+	echo -n '-advsh> '			# prompt
+	read verb obj x
+	if [ $? != 0 ]
+	then	verb=quit		# EOF
+	fi
+
+	case $verb in
+	change)		if [ "$obj" ]
+			then	if ash_lk "$obs $hobs" "$obj"
+				then	set -- $x
+					case "$1" in
+					to)	if [ "$2" ]
+						then	if [ -f $2 ]
+							then	echo "You must destroy $2 first."
+								set --
+							fi
+							if [ "$2" ]
+							then	if mv $obj $2 >&- 2>&-
+								then	echo "The $obj shimmers and turns into $2."
+									obs=`ash_rm "$2 $obs" "$obj"`
+								else	echo "There is a cloud of smoke but the $obj is unchanged."
+								fi
+							fi
+						else	echo 'To what?'
+						fi
+						;;
+					*)	echo "Change $obj to what?"
+						;;
+					esac
+				else	if ash_lk "$kn" "$obj"
+					then	echo 'You must drop it first.'
+					else	echo "I see no $obj here."
+					fi
+				fi
+			else	echo 'Change what?'
+			fi
+			;;
+	clone)		if [ "$obj" ]
+			then	if ash_lk "$obs $hobs" "$obj"
+				then	if [ ! -r $obj ]
+					then	echo "The $obj does not wish to be cloned."
+					else	set -- $x
+						case "$1" in
+						as)	if [ "$2" ]
+							then	if [ -f $2 ]
+								then	echo "You must destroy $2 first."
+								else	if cp $obj $2 >&- 2>&-
+									then	echo "Poof!  When the smoke clears, you see the new $2."
+										obs="$obs $2"
+									else	echo 'You hear a dull thud but no clone appears.'
+									fi
+								fi
+							else	echo 'As what?'
+							fi
+							;;
+						*)	echo "Clone $obj as what?"
+							;;
+						esac
+					fi
+				else	if ash_lk "$kn" "$obj"
+					then	echo 'You must drop it first.'
+					else	echo "I see no $obj here."
+					fi
+				fi
+			else	echo 'Clone what?'
+			fi
+			;;
+	drop)		if [ "$obj" ]
+			then	for it in $obj $x
+				do	if ash_lk "$kn" "$it"
+					then	if [ -w $it ]
+						then	echo "You must destroy $it first."
+						else	if mv $HOME/$KNAP/$it $it >&- 2>&-
+							then	echo "$it: dropped."
+								kn=`ash_rm "$kn" "$it"`
+								obs=`echo $it $obs`
+							else	echo "The $it is caught in your knapsack."
+							fi
+						fi
+					else	echo "You're not carrying the $it!"
+					fi
+				done
+			else	echo 'Drop what?'
+			fi
+			;;
+	enter|go)	if [ "$obj" ]
+			then	if [ $obj != up ]
+				then	if ash_lk "$exs $hexs" "$obj"
+					then	if [ -x $obj ]
+						then	if cd $obj
+							then	echo 'You squeeze through the passage.'
+							else	echo "You can't go that direction."
+							fi
+						else	echo 'An invisible force blocks your way.'
+						fi
+					else	echo 'I see no such passage.'
+					fi
+				else	if cd ..
+					then	echo 'You struggle upwards.'
+					else	echo "You can't reach that high."
+					fi
+				fi
+			else	echo 'Which passage?'
+			fi
+			;;
+	examine)	if [ "$obj" ]
+			then	if [ $obj = all ]
+				then	$obj=`echo $obs $exs`
+					x=
+				fi
+				for it in $obj $x
+				do	if ash_lk "$obs $hobs $exs $hexs" "$it"
+					then	echo "Upon close inspection of the $it, you see:"
+						ls -ld $it 2>&-
+						if [ $? != 0 ]
+						then	echo "-- when you look directly at the $it, it vanishes."
+						fi
+					else	if ash_lk "$kn" "$it"
+						then	echo 'You must drop it first.'
+						else	echo "I see no $it here."
+						fi
+					fi
+				done
+			else	echo 'Examine what?'
+			fi
+			;;
+	feed)		if [ "$obj" ]
+			then	if ash_lk "$obs $hobs" "$obj"
+				then	set -- $x
+					case "$1" in
+					to)	if [ "$2" ]
+						then	shift
+							if PATH=$OPATH $* <$obj 2>&-
+							then	echo "The $1 monster devours your $obj."
+								if rm -f $obj >&- 2>&-
+								then	obs=`ash_rm "$obs" "$obj"`
+								else	echo 'But he spits it back up.'
+								fi
+							else	echo "The $1 monster holds his nose in disdain."
+							fi
+						else	echo 'To what?'
+						fi
+						;;
+					*)	echo "Feed $obj to what?"
+						;;
+					esac
+				else	if ash_lk "$kn" "$obj"
+					then	echo 'You must drop it first.'
+					else	echo "I see no $obj here."
+					fi
+				fi
+			else	echo 'Feed what?'
+			fi
+			;;
+	get|take)	if [ "$obj" ]
+			then	if [ $obj = all ]
+				then	obj="$obs"
+					x=
+				fi
+				for it in $obj $x
+				do	if ash_lk "$obs $hobs" "$it"
+					then	if ash_lk "$kn" "$it"
+						then	echo 'You already have one.'
+						else	if mv $it $HOME/$KNAP/$it >&- 2>&-
+							then	echo "$it: taken."
+								kn="$it $kn"
+								obs=`ash_rm "$obs" "$it"`
+							else	echo "The $it is too heavy."
+							fi
+						fi
+					else	echo "I see no $it here."
+					fi
+				done
+			else	echo 'Get what?'
+			fi
+			;;
+	gripe|bug)	echo 'Please describe the problem and your situation at the time it failed.\nEnd the bug report with a line containing just a Ctrl-D.'
+			cat | mail $MAINT -s 'ash bug'
+			echo 'Thank you!'
+			;;
+	help)		ash_help
+			;;
+	inventory|i)	if [ "$kn" ]
+			then	echo 'Your knapsack contains:'
+				ash_pr $kn
+			else	echo 'You are poverty-stricken.'
+			fi
+			;;
+	kill|destroy)	if [ "$obj" ]
+			then	if [ $obj = all ]
+				then	x=
+					if ask "Do you really want to attempt to $verb them all?"
+					then	obj=`echo $obs`
+					else	echo 'Chicken!'
+						obj=
+					fi
+				fi
+				for it in $obj $x
+				do	if ash_lk "$obs $hobs" "$it"
+					then	if mv $it $HOME/$LIM <&- >&- 2>&-
+						then	if [ $verb = kill ]
+							then	echo "The $it cannot defend himself; he dies."
+							else	echo "You have destroyed the $it; it vanishes."
+							fi
+							obs=`ash_rm "$obs" "$it"`
+						else	if [ $verb = kill ]
+							then	echo "Your feeble blows are no match for the $it."
+							else	echo "The $it is indestructible."
+							fi
+						fi
+					else	if ash_lk "$kn" "$it"
+						then	echo "You must drop the $it first."
+							found=false
+						else	echo "I see no $it here."
+						fi
+					fi
+				done
+			else	echo 'Kill what?'
+			fi
+			;;
+	look|l)		obs=`echo $obs $hobs`
+			hobs=
+			if [ "$obs" ]
+			then	echo 'The room contains:'
+				ash_pr $obs
+			else	echo 'The room is empty.'
+			fi
+			exs=`echo $exs $hexs`
+			hexs=
+			if [ "$exs" ]
+			then	echo 'There are exits plainly labeled:'
+				ash_pr $exs
+				echo 'and a passage directly overhead.'
+			else	echo 'The only exit is directly overhead.'
+			fi
+			;;
+	magic)		if [ "$obj" = mode ]
+			then	if sh -c $cha
+				then	echo 'You had your chance and you blew it.'
+				else	if ask 'Are you a wizard?'
+					then	echo -n 'Prove it!  Say the magic word: '
+						read obj
+						if [ "$obj" = armadillo ]
+						then	echo 'Yes, master!!'
+							wiz=true
+						else	echo "Homie says: I don't think so"
+							cha=true
+						fi
+					else	echo "I didn't think so."
+					fi
+				fi
+			else	echo 'Nice try.'
+			fi
+			;;
+	open|read)	if [ "$obj" ]
+			then	if ash_lk "$obs $hobs" "$obj"
+				then	if [ -r $obj ]
+					then	if [ -s $obj ]
+						then	echo "Opening the $obj reveals:"
+							$CAT < $obj
+							if [ $? != 0 ]
+							then	echo '-- oops, you lost the contents!'
+							fi
+						else	echo "There is nothing inside the $obj."
+						fi
+					else	echo "You do not have the proper tools to open the $obj."
+					fi
+				else	if ash_lk "$kn" "$obj"
+					then	echo 'You must drop it first.'
+						found=false
+					else	echo "I see no $obj here."
+					fi
+				fi
+			else	echo 'Open what?'
+			fi
+			;;
+	quit|exit)	if ask 'Do you really want to quit now?'
+			then	if [ "$kn" ]
+				then	echo 'The contents of your knapsack will still be there next time.'
+				fi
+				rm -rf $HOME/$LIM
+				echo 'See you later!'
+				exit 0
+			fi
+			;;
+	resurrect)	if [ "$obj" ]
+			then	for it in $obj $x
+				do	if ash_lk "$obs $hobs" "$it"
+					then	echo "The $it is already alive and well."
+					else	if mv $HOME/$LIM/$it $it <&- >&- 2>&-
+						then	echo "The $it staggers to his feet."
+							obs=`echo $it $obs`
+						else	echo "There are sparks but no $it appears."
+						fi
+					fi
+				done
+			else	echo 'Resurrect what?'
+			fi
+			;;
+	steal)		if [ "$obj" ]
+			then	if ash_lk "$obs $hobs" "$obj"
+				then	echo 'There is already one here.'
+				else	set -- $x
+					case "$1" in
+					from)	if [ "$2" ]
+						then	shift
+							if PATH=$OPATH $* >$obj 2>&-
+							then	echo "The $1 monster drops the $obj."
+								obs=`echo $obj $obs`
+							else	echo "The $1 monster runs away as you approach."
+								rm -f $obj >&- 2>&-
+							fi
+						else	echo 'From what?'
+						fi
+						;;
+					*)	echo "Steal $obj from what?"
+						;;
+					esac
+				fi
+			else	echo 'Steal what?'
+			fi
+			;;
+	throw)		if [ "$obj" ]
+			then	if ash_lk "$obs $hobs" "$obj"
+				then	set -- $x
+					case "$1" in
+					at)	case "$2" in
+						daemon)	if sh -c "lpr -r $obj"
+							then	echo "The daemon catches the $obj, turns it into paper,\nand leaves it in the basket."
+								obs=`ash_rm "$obs" "$obj"`
+							else	echo "The daemon is nowhere to be found."
+							fi
+							;;
+						*)	echo 'At what?'
+							;;
+						esac
+						;;
+					*)	echo "Throw $obj at what?"
+						;;
+					esac
+				else	if ash_lk "$kn" "$obj"
+					then	echo 'It is in your knapsack.'
+						found=false
+					else	echo "I see no $obj here."
+					fi
+				fi
+			else	echo 'Throw what?'
+			fi
+			;;
+	u|up)		if cd ..
+			then	echo 'You pull yourself up a level.'
+			else	echo "You can't reach that high."
+			fi
+			;;
+	wake)		if [ "$obj" ]
+			then	echo "You awaken the $obj monster:"
+				PATH=$OPATH $obj $x
+				echo 'The monster slithers back into the darkness.'
+			else	echo 'Wake what?'
+			fi
+			;;
+	w|where)	echo "You are in $room."
+			;;
+	xyzzy)		if cd
+			then	echo 'A strange feeling comes over you.'
+			else	echo 'Your spell fizzles out.'
+			fi
+			;;
+	*)		if [ "$verb" ]
+			then	if sh -c $wiz
+				then	PATH=$OPATH $verb $obj $x
+				else	echo "I don't know how to \"$verb\"."
+					echo 'Type "help" for assistance.'
+				fi
+			else	echo 'Say something!'
+			fi
+			;;
+	esac
+done

examples/scripts/precedence

@@ -0,0 +1,75 @@
+# @(#)precedence_test 1.0 91/07/24 Maarten Litmaath
+# test of relative precedences for `&&' and `||' operators
+
+echo "\`Say' echos its argument. Its return value is of no interest."
+case `echo -n` in
+  '') Say () { echo -n "$*" ; } ;;
+   *) Say () { echo "$*\c" ; } ;;
+esac
+
+echo "\`Truth' echos its argument and returns a TRUE result."
+Truth () {
+  Say $1;
+  return 0;
+}
+
+echo "\`False' echos its argument and returns a FALSE result."
+False () {
+  Say $1;
+  return 1;
+}
+
+echo ""
+
+cmd1='$open $test1 && $test2 $close || $test3'
+cmd2='$test1 || $open $test2 && $test3 $close'
+
+grouping_sh=
+grouping_C='( )'
+
+test3='Say 3'
+
+for i in 1 2
+do
+   eval proto=\$cmd$i
+
+   for test1 in 'Truth 1' 'False 1'
+   do
+      for test2 in 'Truth 2' 'False 2'
+      do
+	 for precedence in sh C
+	 do
+	    eval set x \$grouping_$precedence
+	    shift
+	    open=${1-' '}
+	    close=${2-' '}
+	    eval cmd=\""$proto"\"
+	    Say "$cmd   output="
+	    output=`eval "$cmd"`
+	    Say "$output"
+	    read correct || { echo 'Input fubar.  Abort.' >&2; exit 1; }
+	    test "X$output" = "X$correct" || echo "   correct=$correct"
+	    echo ''
+	 done
+
+	 echo ''
+      done
+   done
+done << EOF
+12
+12
+123
+123
+13
+13
+13
+13
+13
+1
+13
+1
+123
+123
+12
+12
+EOF

examples/scripts/shprompt

@@ -0,0 +1,137 @@
+#
+# shprompt -- give a prompt and get an answer satisfying certain criteria
+#
+# shprompt [-dDfFsy] prompt
+#	s = prompt for string
+#	f = prompt for filename
+#	F = prompt for full pathname to a file or directory
+#	d = prompt for a directory name
+#	D = prompt for a full pathname to a directory
+#	y = prompt for y or n answer
+#
+# Chet Ramey
+# chet@ins.CWRU.Edu
+
+type=file
+
+OPTS=dDfFsy
+
+succeed()
+{
+	echo "$1"
+	exit 0
+}
+
+while getopts "$OPTS" c
+do
+	case "$c" in
+	s)	type=string
+		;;
+	f)	type=file
+		;;
+	F)	type=path
+		;;
+	d)	type=dir
+		;;
+	D)	type=dirpath
+		;;
+	y)	type=yesno
+		;;
+	?)	echo "usage: $0 [-$OPTS] prompt" 1>&2
+		exit 2
+		;;
+	esac
+done
+
+if [ "$OPTIND" -gt 1 ] ; then
+	shift $[$OPTIND - 1]
+fi
+
+while :
+do
+	case "$type" in
+	string)
+		echo -n "$1" 1>&2
+		read ans || exit 1
+		if [ -n "$ans" ] ; then
+			succeed "$ans"
+		fi
+		;;
+	file|path)
+		echo -n "$1" 1>&2
+		read ans || exit 1
+		#
+		# use `fn' and eval so that bash will do tilde expansion for
+		# me
+		#
+		eval fn="$ans"
+		case "$fn" in
+		/*)	if test -e "$fn" ; then
+				succeed "$fn"
+			else
+				echo "$0: '$fn' does not exist" 1>&2
+			fi
+			;;
+		*)	if [ "$type" = "path" ] ; then
+				echo "$0: must give full pathname to file" 1>&2
+			else
+				if test -e "$fn" ; then
+					succeed "$fn"
+				else
+					echo "$0: '$fn' does not exist" 1>&2
+				fi
+			fi
+			;;
+		esac
+		;;
+	dir|dirpath)
+		echo -n "$1" 1>&2
+		read ans || exit 1
+		#
+		# use `fn' and eval so that bash will do tilde expansion for
+		# me
+		#
+		eval fn="$ans"
+		case "$fn" in
+		/*)	if test -d "$fn" ; then
+				succeed "$fn"
+			elif test -e "$fn" ; then
+				echo "$0 '$fn' is not a directory" 1>&2
+			else
+				echo "$0: '$fn' does not exist" 1>&2
+			fi
+			;;
+		*)	if [ "$type" = "dirpath" ] ; then
+				echo "$0: must give full pathname to directory" 1>&2
+			else
+				if test -d "$fn" ; then
+					succeed "$fn"
+				elif test -e "$fn" ; then
+					echo "$0 '$fn' is not a directory" 1>&2
+				else
+					echo "$0: '$fn' does not exist" 1>&2
+				fi
+			fi
+			;;
+		esac
+		;;
+	yesno)
+		echo -n "$1" 1>&2
+		read ans || exit 1
+		case "$ans" in
+		y|Y|[yY][eE][sS])
+			succeed "yes"
+			;;
+		n|N|[nN][oO])
+			succeed "no"
+			exit 0
+			;;
+		*)
+			echo "$0: yes or no required" 1>&2
+			;;
+		esac
+		;;
+	esac
+done
+
+exit 1

examples/startup-files/Bash_aliases

@@ -0,0 +1,63 @@
+# Some useful aliases.
+alias texclean='rm -f *.toc *.aux *.log *.cp *.fn *.tp *.vr *.pg *.ky'
+alias clean='echo -n "Really clean this directory?";
+	read yorn;
+	if test "$yorn" = "y"; then
+	   rm -f \#* *~ .*~ *.bak .*.bak  *.tmp .*.tmp core a.out;
+	   echo "Cleaned.";
+	else
+	   echo "Not cleaned.";
+	fi'
+alias h='history'
+alias j="jobs -l"
+alias l="ls -l "
+alias ll="ls -l"
+alias ls="ls -F"
+alias term='set noglob; eval `tset -Q -s `'
+alias pu="pushd"
+alias po="popd"
+
+#
+# Csh compatability:
+#
+alias unsetenv=unset
+function setenv () {
+  export $1="$2"
+}
+
+# Function which adds an alias to the current shell and to
+# the ~/.bash_aliases file.
+add-alias ()
+{
+   local name=$1 value="$2"
+   echo alias $name=\'$value\' >>~/.bash_aliases
+   eval alias $name=\'$value\'
+   alias $name
+}
+
+# "repeat" command.  Like:
+#
+#	repeat 10 echo foo
+repeat ()
+{ 
+    local count="$1" i;
+    shift;
+    for i in $(seq 1 "$count");
+    do
+        eval "$@";
+    done
+}
+
+# Subfunction needed by `repeat'.
+seq ()
+{ 
+    local lower upper output;
+    lower=$1 upper=$2;
+    while [ $lower -le $upper ];
+    do
+        output="$output $lower";
+        lower=$[ $lower + 1 ];
+    done;
+    echo $output
+}
+

examples/startup-files/Bash_profile

@@ -0,0 +1,20 @@
+# Startup file for bash login shells.
+#
+default_dir=/usr/local/lib/
+
+if [ "$PS1" ]; then
+  PS1='\u@\h(\#)$ '
+  ignoreeof=3
+fi
+
+LOGIN_SHELL=true
+
+# If the user has her own init file, then use that one, else use the
+# canonical one.
+if [ -f ~/.bashrc ]; then
+  source ~/.bashrc
+else if [ -f ${default_dir}Bashrc ]; then
+  source ${default_dir}Bashrc;
+  fi
+fi
+

examples/startup-files/Bashrc

@@ -0,0 +1,72 @@
+# Bourne Again SHell init file.
+#
+# Files you make look like rw-rw-r
+umask 002
+
+# Don't make useless coredump files.  If you want a coredump,
+# say "ulimit -c unlimited" and then cause a segmentation fault.
+ulimit -c 0
+
+# Sometimes, there are lots of places that one can find tex inputs.
+export TEXINPUTS=.:$HOME/bin:/usr/lib/tex/inputs:/usr/local/lib/tex/inputs
+
+# Where's the Gnu stuff at?
+GNU=/usr/gnu/bin
+X11=/usr/bin/X11
+
+UTIL_PATH=$GNU:$X11
+STANDARD_PATH=/usr/local/bin:/usr/ucb:/bin:/usr/bin:/usr/etc:/etc:/usr/games
+if [ "$HOSTTYPE" = "sony" ]; then STANDARD_PATH=STANDARD_PATH:/usr/sony/bin; fi
+
+if [ -d $HOME/bin/$HOSTTYPE ]; then
+  MY_PATH=$HOME/bin/$HOSTTYPE
+fi
+
+if [ -d $HOME/bin ]; then
+  MY_PATH=$MY_PATH:$HOME/bin
+fi
+
+if [ -d /usr/hosts ]; then
+  STANDARD_PATH=$STANDARD_PATH:/usr/hosts
+fi
+
+PATH=.:$MY_PATH:$UTIL_PATH:$STANDARD_PATH
+
+# If running interactively, then:
+if [ "$PS1" ]; then
+
+  # Set ignoreeof if you don't want EOF as the sole input to the shell to
+  # immediately signal a quit condition.  This only happens at the start
+  # of a line if the line is empty, and you haven't just deleted a character
+  # with C-d.  I turn this on in ~/.bash_profile so that only login shells
+  # have the right to be obnoxious.
+  # ignoreeof=
+
+  # Set auto_resume if you want to resume on "emacs", as well as on
+  # "%emacs".
+  auto_resume=
+
+  # Set notify if you want to be asynchronously notified about background
+  # job completion.
+  notify=
+
+  # Make it so that failed `exec' commands don't flush this shell.
+  no_exit_on_failed_exec=
+
+  if [ ! "$LOGIN_SHELL" ]; then
+    PS1="\u@\h\$ "
+  fi
+
+  HISTSIZE=256
+  MAILCHECK=60
+
+  # A couple of default aliases.
+  alias j='jobs -l'
+  alias po=popd
+  alias pu=pushd
+  alias ls='ls -F'
+
+  if [ -f ~/.bash_aliases ]; then
+    source ~/.bash_aliases
+  fi
+fi

examples/startup-files/bash-profile

@@ -0,0 +1,54 @@
+HOME=/usr/homes/chet
+MAIL=/usr/homes/chet/mbox
+MAILCHECK=30
+HISTFILE=/usr/homes/chet/.history
+
+MACHINE=$(/usr/local/bin/machine)
+HOST=$(hostname)
+
+PATH1=/usr/homes/chet/bin.$MACHINE:/usr/local/bin/gnu:
+PATH2=/usr/local/bin:/usr/ucb:/bin:/usr/bin/X11:.
+PATH3=/usr/andrew/bin:/usr/bin:/usr/ibm:/usr/local/bin/mh:/usr/new/bin:
+PATH=$PATH1:$PATH2:$PATH3
+
+EDITOR=/usr/homes/chet/bin.$MACHINE/ce
+VISUAL=/usr/homes/chet/bin.$MACHINE/ce
+FCEDIT=/usr/homes/chet/bin.$MACHINE/ce
+
+if [ "$BASH" ] ; then
+	SHELL=$BASH
+else
+	SHELL=/bin/bash
+fi
+
+if [ "$MACHINE" = "ibm032" ] ; then
+	stty erase ^H
+fi
+
+PAGER=/usr/ucb/more
+NNTPSERVER=kiwi
+NS=/nfs/cwjcc/fs1/ns-engr/proj/netsrv/cwpub/proto/src
+
+#
+# Bogus 1003.2 variables.  This should really be in /etc/profile
+#
+LOGNAME=${USER-$(whoami)}
+TZ=EST5EDT
+
+export HOME ENV VISUAL EDITOR MAIL SHELL PATH TERM 
+export PAGER LESS TERMCAP HISTSZIE HISTFILE
+export MAIL MAILCHECK HOST HOSTNAME NNTPSERVER NS LOGNAME TZ
+
+PS1="${HOST}$ "
+PS2='> '
+export PS1 PS2
+
+umask 022
+
+if [ -f /unix ] ; then
+	stty intr ^c
+fi
+
+if [ -f ~/.bashrc ] ; then
+	. ~/.bashrc
+fi

examples/startup-files/bashrc

@@ -0,0 +1,139 @@
+if [ "$PS1" != "" ] ; then
+
+if [ -f /unix ] ; then
+	alias ls='/bin/ls -CF'
+	alias ll='/bin/ls -lCF'
+	alias dir='/bin/ls -bCalF'
+else
+	alias ls='/bin/ls -F'
+	alias ll='/bin/ls -lF'
+	alias dir='/bin/ls -balF'
+fi
+
+alias ss="ps -aux"
+alias mail=/usr/ucb/mail
+alias dot='ls .[a-zA-Z0-9]*'
+alias mroe=more
+alias pwd='echo $PWD'
+alias pdw='echo $PWD'
+alias news="xterm -g 80x45 -e rn -e &"
+alias back='cd $OLDPWD'
+alias manroff="nroff /usr/lib/tmac/tmac.an.4.3"
+alias laser="lpr -Palw2"
+alias lw="lpr -Palw2"
+alias c="clear"
+alias m="more"
+alias j="jobs"
+
+if [ -z "$HOST" ] ; then
+	export HOST=`hostname`
+fi
+
+history_control=ignoredups
+
+psgrep()
+{
+	ps -aux | grep $1 | grep -v grep
+}
+
+#
+# This is a little like `zap' from Kernighan and Pike
+#
+
+pskill()
+{
+	local pid
+
+	pid=$(ps -ax | grep $1 | grep -v grep | awk '{ print $1 }')
+	echo -n "killing $1 (process $pid)..."
+	kill -9 $pid
+	echo "slaughtered."
+}
+
+term()
+{
+        TERM=$1
+	export TERM
+	tset
+}
+
+cd()
+{
+	builtin cd $*
+	xtitle $HOST: $PWD
+}
+
+bold()
+{
+	tput smso
+}
+
+unbold()
+{
+	tput rmso
+}
+
+if [ -f /unix ] ; then
+clear()
+{
+	tput clear
+}
+fi
+
+rot13()
+{
+	if [ $# = 0 ] ; then
+		tr "[a-m][n-z][A-M][N-Z]" "[n-z][a-m][N-Z][A-M]"
+	else
+		tr "[a-m][n-z][A-M][N-Z]" "[n-z][a-m][N-Z][A-M]" < $1
+	fi
+}
+
+watch()
+{
+        if [ $# -ne 1 ] ; then
+                tail -f nohup.out
+        else
+                tail -f $1
+        fi
+}
+
+#
+#       Remote login passing all 8 bits (so meta key will work)
+#
+rl()
+{
+        rlogin $* -8
+}
+
+function setenv()
+{
+	if [ $# -ne 2 ] ; then
+		echo "setenv: Too few arguments"
+	else
+		export $1="$2"
+	fi
+}
+
+function chmog()
+{
+	if [ $# -ne 4 ] ; then
+		echo "usage: chmog mode owner group file"
+		return 1
+	else
+		chmod $1 $4
+		chown $2 $4
+		chgrp $3 $4
+	fi
+}
+
+#
+# Source kshenv for ksh-compatibility definitions
+#
+
+if [ -f ~/.kshenv ] ; then
+	. ~/.kshenv
+fi
+
+fi
+#end of .bashrc

examples/suncmd.termcap

@@ -0,0 +1,30 @@
+#Posted-Date: Fri, 9 Mar 90 18:34:29 EST
+#Date: Fri, 9 Mar 90 18:34:29 EST
+#From: "Eirik Fuller" <wonton.tn.cornell.edu!eirik@ucsbcsl.UUCP>
+#To: bfox@ai.mit.edu (Brian Fox)
+#Subject: Patch to bash 1.05 for SunView
+#
+#I think this works:
+#
+Mu|sun-cmd:am:bs:km:pt:li#34:co#80:cl=^L:ce=\E[K:cd=\E[J:rs=\E[s:
+#
+#Another alternative is to send the ti string at startup time (and, I
+#guess, the te string at exit time); that is how vi works in a cmdtool.
+#The best reason to not do this is that this also disables scrolling
+#which, as I understand it, is why anyone would use cmdtool in the
+#first place.  Sending the ti string at startup time would do strange
+#things on other systems too; in xterm it would use the alternate
+#screen.
+#
+#The problem with cmdtool, in case that is less than obvious, is that
+#almost none of the capabilities advertised in /etc/termcap are enabled
+#while scrolling is enabled.  It has other problems too, like being
+#part of an outdated proprietary windowing system, but there's probably
+#no need to dwell on that.  In a sense, though, the sun-cmd termcap
+#entry doesn't lie about the capabilities; I think the termcap man page
+#does warn about some terminals having cursor motion capabilities only
+#in the "ti/te window".
+#
+#A general solution to this problem would require a termcap capability
+#which somehow tells which features are available outside of the ti/te
+#window.  There is no such capability in termcap now, of course.