Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: version B 2.10.PCS 1/10/84; site mtuxo.UUCP
Path: utzoo!watmath!clyde!burl!ulysses!mhuxr!mhuxt!houxm!mtuxo!cjb
From: cjb@mtuxo.UUCP (c.bamford)
Newsgroups: net.sources
Subject: cd commands that remember where you've been
Message-ID: <989@mtuxo.UUCP>
Date: Sun, 22-Sep-85 21:08:48 EDT
Article-I.D.: mtuxo.989
Posted: Sun Sep 22 21:08:48 1985
Date-Received: Mon, 23-Sep-85 02:48:20 EDT
Organization: AT&T Information Systems Labs, Holmdel NJ
Lines: 320

If you spend a lot of time prowling directory trees, the following Korn
shell functions are very handy. They provide a version of the "cd"
command that remembers which directories you've visited since
login. Remembered directories are maintained in a stack and labelled
with small integers; to cd to a directory you've already visited,
it is only necessary to say something like:
	r 3
which makes the 3rd directory in the stack the current working directory,
avoiding the necessity of retyping /horribly/long/directory/names.

These functions were inspired by the Csh pushd/popd/dirs commands, and
go much further than the Ksh "cd -" command. Although they are written
for the Korn shell, I have versions for Csh and /bin/sh if anyone
has trouble with the conversions involved. Overly verbose documentation
(including a little wall chart) appears in the shell file itself.

Cliff Bamford
Consultant to AT&T Lincroft NJ room 113A-3L210 phone (210) 576 2133
... ihnp4!mtuxo!cjb

Note: this is NOT an installation shell script - just put it in a file
------------------cut here--cut here--cut here------------------------
#
# Ksh versions of the directory-stack management functions by bamford 21Sep85
#
# The o,p,q,r,s commands replace cd. They maintain a stack of directories
# visited by you since login. There are commands to visit (cd to) a new
# directory, display the stack, reorder the stack, etc.
#
# To use these functions: copy this text to a file in your home directory
# then insert the following lines in your .profile:
#	unalias r	     # ksh has a hardwired alias for r='fc -e -'
#	alias -x x='fc -e -' # now you can say "x ect=etc g" to fix last grep
#	. <this file name>   # define the functions
#	alias cd=p           # experts prefer alias cd=s
# 
# The q command displays the directory stack. If your userid is foobar, and
# your $HOME directory is /u/foobar, then this is what the q command displays
# immediately after you logon:
#	q
#	0=/u/foobar
#
# This means that the stack consists of a single directory numbered 0.
# Directories on the stack are always numbered for easy reference, directory
# number 0 is ALWAYS your current working directory. Now say you do two
# cds in a row:
#	cd /usr/games
#	0=/usr/games  1=/u/foobar
#	cd /news/spool/net
#	0=/news/spool/net  1=/usr/games  2=/u/foobar
#
# Since cd is aliased to p (the PUSH directory command), your movement
# thru the directory tree causes the stack to grow, always keeping the
# current working directory at the top of the stack (position 0) and 
# pushing previous directories down the stack for possible future reference.
# All the usual magic stuff works:
#	cd ~henry
#	0=/v/henry  1=/news/spool/net  2=/usr/games  3=/u/foobar
#	cd 
#	0=/u/foobar  1=/v/henry  2=/news/spool/net  3=/usr/games
#
# Notice that last cd -- the opqrs commands never put a directory on the
# stack if it's already there (it just moves the requested directory to
# the top of the stack, making it the current working directory).
# The r command is another way to reorder the stack. Without operands 
# it interchanges the top two directories:
#	r
#	0=/v/henry  1=/u/foobar  2=/news/spool/net  3=/usr/games
# 
# You can tell r to reach down further into the stack:
#	r 3
#	0=/usr/games  1=/v/henry  2=/u/foobar  3=/news/spool/net
#	r 3
#	0=/news/spool/net  1=/usr/games  2=/v/henry  3=/u/foobar
#
# The s command SWITCHES (replaces) the directory at the top of
# the stack with the one you name:
#	s ..
#	0=/news/spool  1=/usr/games  2=/v/henry  3=/u/foobar
#	s
#	0=/u/foobar  1=/news/spool  2=/usr/games  3=/v/henry
#
# As shown in the last example, s without an operand means switch me
# to my home directory -- which, in this case was already in the stack
# so it got moved to the 0 (current working directory) position.
# Finally, the o command POPs (removes directories) off the stack:
#	o
#	0=/news/spool  1=/usr/games  3=/v/henry
# 
# You can tell o to keep popping until the nth directory is at the top:
#	o 3
#	0=/v/henry
#
# None of the commands let you create an empty stack:
#	o 99
#	0=/u/foobar
#
# Which is an easy way to clean up the stack completely.
# All of this is much harder to explain than it is to use. The following
# chart really tells the whole story:
#
# command	description
# -------	-----------
# p X		push directory X (default $HOME) onto top of stack
# s X		switch (replace) top of stack with X (default $HOME)
# q		display the stack (no operands allowed)
# r n		reorder - make the nth directory (default 1) top of stack
# o n		pop directories until the nth (default 1) is top of stack
#
#
####################End of Documentation#################################
#
# CDS is the directory stack CDSN is the highest valid index thereto
#
CDS[0]=$HOME
let CDSN=0
export CDS
export CDSN

function tellq		##### describe the q command
{
	print "The q command displays the directory stack (queue)."
	print "It ignores all operands except ?, which produces this note."
}

function q		##### display the queue
{
	if [ $1xx = \?xx ]
	   then tellq
	   return
	fi
	let i=0
	while [ $i -le $CDSN ]
	      do
	      if [ ${CDS[$i]} ]
		 then print -n $i"="${CDS[$i]}"  "
	      fi
	      let i=i+1
	      done
	print -n \\n
}

function oo		##### internal - pop 1 item off queue
{
	if [ $CDSN -eq 0 ]
	   then CDS[0]=$HOME
	   return
	fi
	let i=0
	let j=$CDSN
	while [ $i -le $j ]
	      do
	      let k=$i+1
	      CDS[$i]=${CDS[$k]}
	      let i=$i+1
	      done
	unset CDS[$i]
	unset CDS[$j]
	let CDSN=${CDSN}-1
}

function tello		##### explain how to use o 
{
	print "The o n command pops the stack until the nth directory is top."
	print "If this leaves the stack empty, \$HOME becomes single top."
	print "Usage: o      (pop once)"
	print "   or: o 1    (ditto)"
	print "   or: o n    (pop until the nth directory is at top)" 
	print "   or: o 99   (clean up stack completely)"
}

function o		##### pop n items off queue (default is 1)
{
	if [ $# -lt 1 ] 
	   then oo
	   cd ${CDS[0]}
	   q
	   return
	fi
	if [ $# -gt 1 ]
	   then print "o: too many parms [$*]"
	   return 1
	fi
	if [ $1xx = ?xx ]
	   then tello
           return 1
	fi
	case $1 in
	   [!1-9] ) print "o: parm [$*] must be 1-9"; return 1;;
	esac
	let n=$1
	while [ $n -gt 0 ]
	      do
	      oo
	      let n=$n-1
	      done
	cd ${CDS[0]}
	q	
}

function chekstak	##### if stack contains $1 set $in to its index
{
	let in=0
	while [ $in -le $CDSN  ]
	      do
	      if [ $1 = ${CDS[$in]} ]
                 then return 0
	         fi
              let in=$in+1
	      done
        return 1
}
function rr		##### internal - switch top and CDS[$1], $1 is good
{
	if [ $1 -gt $CDSN ]
	   then q
	   return
	fi
	cd ${CDS[$1]}	##### if cd fails, we abort w/o changing CDS
	rrx=${CDS[0]}
	CDS[0]=${CDS[$1]}
	let rri=$1
	while [ $rri -gt 1 ]
	      do
	      let rrj=$rri-1
	      CDS[$rri]=${CDS[rrj]}
	      let rri=$rri-1
	      done
	CDS[1]=$rrx
	q
}

function r		##### bring CDS[$1] to top of q
{
	if [ $# -lt 1 ]
	   then rr 1
	   return  
	fi
	if [ $# -gt 1 ]
	   then print "r: too many parms [$*]"
	   return 1
	fi
	if [ $1xx = ?xx ]
	   then print "The r n command reorders the stack, bringing"
	        print "the nth directory to the top."
	        print "Usage: r 1  (interchange top and 1st directory)"
	        print "   or: r    (ditto)"
		print "   or: r n  (bring nth directory to top)"
		return
	fi
	if [ $1xx = 0xx ]
	   then q
	   return
	fi
	case $1 in
	     [!1-9] ) print "r: parms [$*] must be 0-9";return 1;;
	esac
	if [ $1 -lt 1 -o $1 -gt $CDSN ]
	   then print "r: parm [$*] out of range - max is $CDSN"
	   return 1
	fi
	rr $1
}

function p		#### push directory x onto stack
{
	if [ $# -gt 1 ]
	   then print "p: too many parms [$*]"
	   return 1
	fi
	if [ $1xx = ?xx ]
	   then print "The p xxx command puts directory xxx on top."
		print "Usage: p /usr/bin  (puts /usr/bin on top)"
		print "   or: p           (go to HOME directory)"
		print "   or: p \~	  (ditto)"
		print "   or: p \`pwd\`     (synch opqrs to real world)"
	   return
	fi
	cd $1		#### if cd fails, exit w/o change
	pd=`pwd`
	if chekstak $pd
	   then r $in
	   return
	fi
	let pi=$CDSN+1
	while [ $pi -gt 0 ]
	      do
	      let pj=$pi-1
	      CDS[$pi]=${CDS[pj]}
	      let pi=$pi-1
	      done
	CDS[0]=$pd
	let CDSN=$CDSN+1
	q
}

function s		#### switch $1 onto top of stack
{
	if [ $# -gt 1 ]
	   then print "s: too may parms [$*]"
	   return 1
	fi
	if [ $1xx = ?xx ]
	   then print "The s xxx command replaces the top of stack with"
		print "directory xxx. A missing operand means HOME."
	        print "Usage: s ..	(cd to the parent of this directory)"
		print "   or: s bin     (go one directory lower)"
	        print "   or: s \~       (go to home directory)"
		print "   or: s         (ditto)"
		return
	fi
	cd $1		#### if cd fails exit without prejudice
	sd=`pwd`
	if chekstak $sd
	   then r $in
	   return
	fi
	CDS[0]=$sd
	q
}


Brought to you by Super Global Mega Corp .com