xref: /onnv-gate/usr/src/tools/scripts/wx.sh (revision 11407:a911350b5377)

#!/bin/ksh -p
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#

#
# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#

# wx -- workspace extensions.  Jeff Bonwick, December 1992.

# The bugster cat/subcat = consolidation/os-net-tools

version() {
	if [[ $(whence $0) = "/opt/onbld/bin/wx" ]] && \
	    pkginfo SUNWonbld > /dev/null 2>&1; then
		pkginfo -l SUNWonbld | egrep "PKGINST:|VERSION:|PSTAMP:"
	else
		ls -l $(whence $0)
	fi
}

ring_bell() {
	# Sound bell to stderr, no newline
	print -u2 "\007\c"
}

fail() {
	ring_bell
	# output error message to stderr
	print -u2 "$@ Aborting $command."
	exit 1
}

ask() {
	typeset question=$1 default_answer=$2
	if [ -z "$default_answer" ]; then
		echo "$question \c"
	else
		echo "$question [$default_answer]: \c"
	fi
	read answer
	[ -z "$answer" ] && answer="$default_answer"
}

yesno() {
	typeset question="$1"
	answer=
	while [ -z "$answer" ]; do
		ask "$question" y/n
		case $answer in
			y|yes)	answer=yes;;
			n|no)	answer=no;;
			*)	answer=;;
		esac
	done
}

ok_to_proceed() {
	yesno "$*"
	if [[ "$answer" == no ]]; then
		echo "Exiting, no action performed"
		exit 1
	fi
}

escape_re() {
	# Escape the . so they are treated as literals in greps.
	echo "$1"|sed 's{\.{\\.{g'
}

remove_local_nt_entry() {
	# remove entries in local nt cache
	grep -v "^$(escape_re $1) " $wxdir/local_nametable > \
		$wxtmp/local_nametable
	[[ ! -f $wxtmp/local_nametable ]] && \
		fail "Error: cannot create $wxtmp/local_nametable"
	mv -f $wxtmp/local_nametable $wxdir/local_nametable ||
		fail "Error: cannot create $wxdir/local_nametable."
}

remove_renamed_entry() {
	# remove entries in renamed list
	# assuming arg is the new filename to remove
	grep -v "^$(escape_re $1) " $wxdir/renamed > \
		$wxtmp/renamed
	[[ ! -f $wxtmp/renamed ]] && fail "Error: cannot create $wxtmp/renamed"
	mv -f $wxtmp/renamed $wxdir/renamed ||
		fail "Error: mv -f $wxtmp/renamed $wxdir/renamed failed"
}

add_local_nt_entry() {
	# Add workspace nametable entry to local nt cache for better perf.
	[[ -r $wsdata/nametable ]] || return 0
	if ! grep -q "^$(escape_re $1) " $wxdir/local_nametable; then
		# add entries from workspace nt to local nt cache
		grep "^$(escape_re $1) " $wsdata/nametable >> \
			$wxdir/local_nametable
		[[ ! -f $wxdir/local_nametable ]] && \
			fail "Error: cannot create $wxdir/local_nametable"
	fi
	return 0
}

remove_active_entry() {
	# Remove entry from active list
	# $1 is the filepath to remove

	nawk '
	$1 == target {
		# Get past filepath line
		while(NF > 0)
			getline;
		# Get past blank lines
		while(NF == 0)
			getline;
		# Get past comments
		while(NF > 0)
			getline;
		# Get past ending blank lines
		while(NF == 0) {
			if (getline) {
				continue;
			} else {
				next;
			}
		}
	}
	# print the other active list entries
	{ print $0; } ' target=$1 $wxdir/active >$wxtmp/tmp_active ||
		fail "Error: cannot create $wxtmp/tmp_active."
	if mv -f $wxtmp/tmp_active $wxdir/active; then
		echo "$1 removed from active list."
		remove_local_nt_entry $1
	else
		cat >&2 <<-EOF
An error occured trying to remove $1 from the active list.
The active list may be corrupt.  You should check it out and 
possibly run '$ME update' to fix.
		EOF
		fail
	fi
}

rename_active_entry() {
	# renamed $1 to $2 filepath in active list
	sed "s|^$(escape_re $1)$|$2|" $wxdir/active >\
		$wxtmp/active || fail "Error: cannot create $wxtmp/active."
	mv -f $wxtmp/active $wxdir/active || \
		fail "Error: mv $wxtmp/active $wxdir/active failed."
}

is_active() {
	# Return 0 if filepath arg is found in active list.
	wx_active|grep -q "^$(escape_re $1)$"
}

#
# ask user if s/he wants to remove an entry from the active list.
# Will not remove entries that differ from parent or are new.
#
ask_remove_active_entry() {
	# if an arg is passed in then this is assumed to be the filepath
	# otherwise we assume the variables were set properly by the caller
	if [[ $# -eq 1 ]]; then
		dir=$(dirname $1)
		file=$(basename $1)
		filepath=$1

		if [[ ! -f $file ]]; then
			echo "Cannot find $file"
			return 1
		fi
	fi

	if is_active $filepath; then
		if wx_pnt_filepath $filepath; then
			if ! cmp -s $file $parentfilepath; then
				cat <<-EOF

The file $filepath
differs from parent file:
$parentfilepath
and will remain in the active list.
				EOF
				return
			fi
		else
			# New file, leave in active list.
			cat <<-EOF
$filepath
is new and will remain in active list.  Use:
'$ME uncreate $filepath'
to remove from active list.
			EOF
			return
		fi
		# Remove entry from active list because it is the same as
		# the parent.
		echo "There is no difference between $filepath and the parent"
		echo "$parentfilepath"
		yesno "Okay to remove $filepath from active list?"
		if [[ "$answer" == 'yes' ]]; then
			remove_active_entry $filepath
		fi
	fi
}

refresh_pnt_nt_cache() {
	# Refresh the parent nametable cache if necessary.
	# Note, this is a cache for the parent nametable entries that
	# have the same hash as the local active and renamed files.

	# no parent so nothing to update.
	[[ -z $parent ]] && return 0

	if [[ ! -r $parent/Codemgr_wsdata/nametable ]]; then
		fail "Error: cannot read $parent/Codemgr_wsdata/nametable"
	fi

	if [[ ! -f $wxtmp/parent_nametable ||
	    $parent/Codemgr_wsdata/nametable -nt $wxtmp/parent_nametable ||
	    $wsdata/parent -nt $wxtmp/parent_nametable ||
	    $wxdir/local_nametable -nt $wxtmp/parent_nametable ]]; then
		cut -f2- -d' ' $wxdir/local_nametable > $wxtmp/hash_list

		if [[ ! -f $wxtmp/hash_list ]]; then
			fail "Error: cannot create $wxtmp/hash_list."
		fi

		if [[ -s $wxtmp/hash_list ]]; then
			# Use hash list to get only the parent files
			# we're interested in.
			fgrep -f $wxtmp/hash_list \
			    $parent/Codemgr_wsdata/nametable \
				 > $wxtmp/parent_nametable
			[[ ! -f $wxtmp/parent_nametable ]] && \
				fail "Error: cannot create $wxtmp/parent_nametable"
		else

			# There aren't any files to search for so just
			# update the timestamp.

			touch $wxtmp/parent_nametable
		fi
	fi
}

# add an active file to the new list
add_new() {
	typeset efp=$(escape_re $1)
	# update new file list
	if [[ ! -f $wxdir/new ]]; then
		touch $wxdir/new || fail "Error: cannot create $wxdir/new."
	fi
	if is_active $1 && ! grep -q "^$efp$" $wxdir/new; then
		echo "$1" >> $wxdir/new || fail "Error: cannot update $wxdir/new."
	fi
}

# remove a file from the new list
remove_new() {
	# remove entries in new list
	typeset efp=$(escape_re $1)
	if [[ -f $wxdir/new ]] && grep -q "^$efp$" $wxdir/new; then
		grep -v "^$efp$" $wxdir/new > $wxtmp/new
		[[ ! -f $wxtmp/new ]] && fail "Error: cannot create $wxtmp/new"
		mv -f $wxtmp/new $wxdir/new || fail "Error: cannot create $wxdir/new."
	fi
}

update_active() {
	# Try to add an entry to the active list
	typeset efp=$(escape_re $1)

	if ! is_active $1; then
		if [[ -n "$comment_file" ]]; then
			# Use sed to remove any empty lines from comment file.
			(echo $1; echo; sed '/^[ 	]*$/d' $comment_file;\
				echo) >>$wxdir/active ||
				fail "Could not update active list."
		else
			(echo $1; echo; wx_show_comment; echo) \
			    >> $wxdir/active ||
				fail "Could not update active list."
			echo "Remember to edit the comment in the active list "\
				 "(use '$ME ea')."
		fi
		add_local_nt_entry $1
	fi  # End if not in active list
}

sort_active() {
	typeset origfp=$filepath

	# Note must use filepath for wx_show_comment
	wx_active | sort | while read filepath; do
		(print "$filepath"; print; wx_show_comment; print)
	done > $wxtmp/active_sort || \
		fail "Error: cannot create $wxtmp/active_sort"
	mv -f $wxtmp/active_sort $wxdir/active || \
		fail "Error: cannot create $wxdir/active"

	filepath=$origfp
}

sort_renamed() {
	sort $wxdir/renamed > $wxtmp/renamed_sort || \
		fail "Error: cannot create $wxtmp/renamed_sort"
	mv -f $wxtmp/renamed_sort $wxdir/renamed || \
		fail "Error: cannot create $wxdir/active"
}

update_active_comment() {
	# replace comment in active list entry with contents of $comment_file
	nawk '
	# find active list entry to modify
	$1 == filepath {
		# print filepath line
		while(NF > 0){
			print $1;
			getline;
		}
		#print 1 blank (delimit)
		print "";
		# Get past blank lines
		while(NF == 0){
			getline;
		}
		# Get past active entry comments
		# append to or replace comment
		if (comment_mode == "append"){
			while(NF > 0) {
				# output existing comments
				print $0;
				getline;
			}
		} else {
			# get past existing comments
			while(NF > 0) getline;
		}

		# output new comments
		while (getline < comments){
			# do not print blank lines
			if (NF > 0)
				print $0
		}
		close comments
		# print delimiting blank line
		printf "\n"

		# Get past ending blank lines in active entry
		NF=0
		while(NF == 0) {
			if (getline) {
				continue;
			} else {
				next;
			}
		}
	}
	# print the other active list entries
	{ print $0; } ' filepath=$1 comment_mode=$comment_mode \
		comments=$comment_file $wxdir/active >$wxtmp/tmp_active && \
		mv $wxtmp/tmp_active $wxdir/active
	if [[ $? -eq 0 ]]; then
		echo "$1 comment(s) updated in active list."
	else
		cat <<-EOF

An error occured trying to update comments for $1 in the active list.
The active list ($wxdir/active) may be corrupt.  You should check it out
and possilbly run '$ME ea' to fix.

		EOF
		fail
	fi
}

lookup_parent() {
	# Find a local file's parent filepath.
	# Returns 1 if not found (local file is new)
	# Sets env var. parentfilepath and parenthash if found
	# Requires a file arg.
	# Updates local and parent nt caches.

	typeset efp parententry localfile hash1 hash2 hash3 hash4 \
		local_nt pnt_nt

	parentfile=
	parenthash=

	if [[ -z $parent ]]; then
		cat >&2 <<-EOF

Warning: there is no parent for the current workspace so local file:
$1
is assumed to be new.
		EOF
		return 1
	fi
	if [[ ! -f $wsdata/nametable ]]; then
		# Nothing has been brought over so assuming new file.
		cat >&2 <<-EOF

Warning: the $wsdata/nametable
doesn't exist so
$1
is assumed to be new.
		EOF
		return 1
	fi

	if [[ ! -r $parent/Codemgr_wsdata/nametable ]]; then
		fail "Error: cannot read $parent/Codemgr_wsdata/nametable."
	fi
	if [[ ! -f $wxtmp/parent_nametable ]] || $need_pnt_refresh; then
		refresh_pnt_nt_cache
		need_pnt_refresh=false
	fi
	if [[ ! -f $wxdir/local_nametable ]]; then
		touch $wxdir/local_nametable ||
			fail "Error: cannot create $wxdir/local_nametable."
	fi

	efp=$(escape_re $1)

	for local_nt in $wxdir/local_nametable $wsdata/nametable; do

		# May be multiple entries in nametable, see if one
		# matches parent.

		grep "^$efp " $local_nt |\
		while read localfile hash1 hash2 hash3 hash4; do
			for pnt_nt in $wxtmp/parent_nametable \
			    $parent/Codemgr_wsdata/nametable; do
				# get current parent nt entry
				parententry=$(grep \
				    " $hash1 $hash2 $hash3 $hash4$" $pnt_nt)
				if [[ -n "$parententry" ]]; then
					# found parent entry
					parentfile=$(echo "$parententry" |\
						cut -f1 -d' ')
					parenthash="$(echo "$parententry" |\
						cut -f2- -d' ')"
					if [[ "$local_nt" == \
						"$wsdata/nametable" ]]; then

						# Update the local nt
						# hash cache if parent
						# found and local
						# workspace nt used.

						add_local_nt_entry $localfile
					fi
					if [[ $pnt_nt == \
					    $parent/Codemgr_wsdata/nametable ]]
					then

						# Update the parent nt
						# hash cache if actual
						# parent nt used.

						echo $parententry >>\
						    $wxtmp/parent_nametable
					fi

					# break out of all the loops if
					# parent found

					break 3
				fi
			done # for pnt_nt
		done # while read active file
	done # for local_nt

	if [[ -z "$parentfile" ]]; then
		# parent filepath not found.
		return 1
	else
		# parent filepath found.
		return 0
	fi
}

#
# Detect if a file was locally renamed
#
renamed() {
	# Return 0 if renamed, 1 if not locally renamed
	# parentfile and parenthash set as side effect
	# Must be used by commands that set filepath (like wx_eval)

	if [[ ! -f $wxdir/renamed ]]; then
		update_renamed_dir
	fi

	# new is the new filename in the current ws, old is the previous
	# filename that should exist in parent ws.

	if grep -q "^$(escape_re $filepath) " $wxdir/renamed; then
		if lookup_parent $filepath; then
			return 0
		else

			# New files aren't in $wxdir/renamed so no
			# parent is a problem

			fail "Error: renamed $filepath but no matching parent"\
				"file in $parent"
		fi
	else
		# not locally renamed
		return 1
	fi
}

wx_pnt_filepath() {
	# return 0 if parent file found. Side effect: sets parentfilepath
	# and parentsdot.  parentfile and parenthash are set via lookup_parent.

	# if an arg is passed in then this is assumed to be the filepath
	# otherwise we assume the variables were set properly by the caller
	if [[ $# -eq 1 ]]; then
		dir=$(dirname $1)
		file=$(basename $1)
		filepath=$1
	fi

	# Find the parent filename
	if lookup_parent $filepath; then
		parentfilepath=$parent/$parentfile
		parentsdot=$parent/$(dirname $parentfile)/SCCS/s.$(basename \
		    $parentfile)
		if [[ -f $parentfilepath && -s $parentsdot ]]; then
			# found
			return 0
		else
			fail "Error: located parent filepath $parentfilepath"\
				"but file does not exist or SCCS file is empty."
		fi
	fi

	# wasn't found
	return 1
}

get_pb_output() {
	# Get output of putback -n (useful for parsing to find diffs between
	# workspaces).  Creates $wxtmp/putback.err and $wxtmp/putback.out
	typeset -i rc=0
	typeset origdir=$(pwd)
	# clean up if interrupted.
	trap "rm $wxtmp/putback.out;exit 1" HUP INT QUIT TERM

	cat <<-EOF
Doing a '$PUTBACK -n $*' to find diffs between workspaces.
Please be patient as this can take several minutes.
	EOF

        cd $workspace

	$PUTBACK -n $* 2>$wxtmp/putback.err >$wxtmp/putback.out
	rc=$?
	# Note a blocked putback returns a 2 but is not a problem.
	if [[ $rc -ne 0 && $rc -ne 2 ]]; then
		rm $wxtmp/putback.out
		fail "Error, $PUTBACK -n $* failed. See $wxtmp/putback.err"\
			"for details."
	fi
	trap - HUP INT QUIT TERM
        cd $origdir
	return 0
}

wx_usage() {
	version

	cat << EOF

See <http://www.opensolaris.org/os/community/on/wx/> for usage tips.

Usage:  $ME command [-D] [args]

        -D turn on debugging for any command (output to stderr)

===================== Initialization and Update Commands ====================
        $ME init [-f(t|q|n) [-s]] [src-root-dir]     
                        initialize workspace for $ME usage
                        -f(t|q|n): non-interactive mode of update.  Use this
                                   to keep init from asking questions.
                            -ft: thorough update (update both active and 
                                 renamed lists with all diffs between parent
                                 and current workspace).
                            -fq: quick update (update active list with files
                                 currently checked out in current workspace).
                            -fn: no update (just create empty active and 
                                 renamed lists if they don't exist already).
                            -s:  keep active list sorted by default.  Must
                                 follow a -f(t|q|n) flag.
                        src-root-dir: optional path relative to top of 
                                      workspace where wx will search for files.
                                      Use "." to set src-root to top of
                                      workspace.  Default is usr.
        $ME update [-q|-r] [-s]
                        Update the active and renamed file lists by
                        appending names of all files that have been
                        checked out, changed, created or renamed as
                        compared to the parent workspace.  This is the
                        most accurate way of updating but it is slow.
                        All files in the workspace must be under SCCS
                        control in order for update to find them.  Note,
                        this operation can be sped up in some cases by
                        setting the PUTBACK env. variable to use 
                        "cm_env -g -o putback". (See
                        http://webhome.holland.sun.com/casper/ for more
                        info about the turbo def.dir.flp tool).

                        -q: quick update (only updates active list with
                            files currently checked out in workspace).  This
                            is faster but will not find renames or files that
                            have been checked-in/delget'ed.
                        -r: only update the renamed list.  Does not update
                            the active list.
                        -s: sort the active list.

======================== Information Commands ===========================
        $ME list [-r|-p|-w] list active files (the ones you are working on)
                        -r: list only renamed active files.
                        -p: output list of both active and renamed files 
                            suitable for input to putback. 
                        -w: output list of both active and renamed files
                            suitable for input to webrev (see $ME webrev 
                            subcommand below).
        $ME active          alias for list 
        $ME pblist          alias for list -p (see above).

        $ME renamed [-a|-d|-p]
                         list locally renamed files. The output format is:
                         "new_name previous_name". Note, deleted files are
                         a special case of rename. 
                        -a: list only renamed active files (same as list -r)
                        -d: list only deleted files
                        -p: show "new_name parent_name" (Note, parent_name 
                            may not be the same as previous_name)
        $ME new [-t]    List new active files (files that exist in child only)
                        Note, should be run before reedit (see reedit below).
                        -t: thorough, does not use new cache (slower but more
                            accurate if new cache isn't current).
        $ME out         find all checked-out files in workspace
        $ME info        [file ...] show all info about active files

        $ME diffs [file ...]
                        show sccs diffs for files (current vs previous
                        local version).  Will show diffs for all active
                        files if no files given on command line.  Will
                        use WXDIFFCMD environment variable if set.  Hint,
                        try: export WXDIFFCMD="diff -bwU5"

        $ME tdiffs [file ...]
                        Similar to diffs but new files are also displayed.
                        New files are those listed by '$ME new'.

        $ME pdiffs [file ...]   show diffs against parent files
                        Will show diffs between local file and it's
                        parent for all active files if no files given on
                        command line.  Will use WXDIFFCMD environment
                        variable if set. 

        $ME tpdiffs [file ...]   show diffs against parent files
                        Similar to pdiffs but new files are also displayed.
                        A file is considered new if it does not exist in
                        the parent.

        $ME prt [-y]    show sccs history for all active files

        $ME comments    display check-in comments for active files
        $ME bugs [-u]   display all bugids in check-in comments
        $ME arcs [-u]   display all ARC cases in check-in comments
        $ME pbcom [-v] [-u] [-N]  display summarized comments suitable for putback
                        Default is to display only bugs and arc cases. Will
                        display warnings about non-bug comments to stderr.
                        -v: display all comments verbatim including non-bug/arc 
                        -u: prevent sorting, order determined by active list
                        -N: don't check bug synopsis against bug database

======================== File Manipulation Commands ======================
        $ME edit [-s] [file ...]        
                        check out either file(s) on command line or
                        all active files if no file args.
                        (Updates the active list.)
                        -s: silent, less sccs diagnostic output.  This is 
                            true for the other commands that accept the 
                            -s flag.
        $ME checkout    Alias for edit command.
        $ME co          Alias for edit command.

        $ME unedit [-s][-f] [file ...] 
                        Returns file(s) to state prior to edit/checkout
                        Note, files will be unlocked and any changes made
                        when file was last checked out will be lost.
                        Unedit all active files if no files listed on
                        command line.  Removes active list entry if there
                        are no diffs between local and parent file.
                        (Updates active list)
                        -f: force unedit, non-interactive. Will backup
                            if wx files newer than last backup.
        $ME uncheckout  Alias for unedit command.
        $ME unco        Alias for unedit command.

        $ME delget [-(c|C) comment_file][-s][-f] [file ...] 
                        Check in all active files or files on command
                        line. Check in comments will be those in active
                        file.  See '$ME comments' for more info.
                        -c comment_file: use comment(s) in specified comment
                                         file when checking in file(s). Note,
                                         each comment should be on new line,
                                         blank lines not allowed.  Existing
                                         comments in active list will be 
                                         replaced by contents of comment_file.
                        -C comment_file: Similar to -c but comments are 
                                         appended to current active list 
                                         comments.
                        -f: force checkin, no checks, non-interactive.
                            Use this if your sure the files okay to checkin
                            otherwise this command will check for
                            keyword problems. Will backup if wx files
                            newer than last backup.

                        NOTE: use redelget to reset new file's version to 1.1.

        $ME checkin     Alias for delget command.
        $ME ci          Alias for delget command.

        $ME create [-(c|C) comment_file] [-f] [-o] file [file ...]
                        Creates one or more files in the workspace.
                        (Updates active list)
                        -(c|C) comment_file: see delget
                        -f: force create regardless of warnings,
                            (non-interactive).
                        -o: also check out file for further editing.

        $ME uncreate [-f] [file ...]
                        Undoes the create of a new file.  The file's
                        active list entry, its SCCS history and the
                        entry in the workspace nametable will be removed
                        but the file will stay in the workspace.
                        Will uncreate all new files in active list if
                        no file argument is specified.
                        -f: force uncreate, non-interactive. Will backup
                            if wx files newer than last backup.

        $ME get [-k][-r #][-p] [file ...]
                        Get a copy of all active files or files on command
                        line.  By default this is a read only version of
                        the file.
                        -r #: get specified version #
                        -p: output to stdout
                        -k: don't expand the sccs ID string
        $ME extract     Alias for get command.

        $ME reedit [-m] [-s] [file ...]
                        Collapse the sccs delta (file history) such that
                        all changes made to the file in the current
                        workspace are now in one delta.  If no files are
                        given on command line then all the active files
                        are processed.  The files are left in a checked
                        out state so you can make further changes if a
                        resolve to make all your changes look like a
                        single delta.  This eliminates the uninteresting
                        leaf deltas that arise from resolving conflicts,
                        so your putbacks do not contain a bunch of noise
                        about every bringover/resolve you did in the
                        interim.  Accepts the same compression flags as
                        $ME backup.  If [file ...] given, wx only
                        reedits files passed on command line.  This adds
                        files to active list if not already there.
                        
                        NOTE: reedit is appropriate for leaf workspaces
                        ONLY -- applying reedit to an interior-node
                        workspace would delete all childrens comments
                        and confuse Teamware tools in general.
                        
                        NOTE: if files are listed as new that are not
                        then DO NOT use the reedit as it will destroy
                        the file history.

                        NOTE: if a file is new reedit will leave the
                        file checked out so in order to keep the delta
                        version at 1.1 redelget must be used for
                        checkin.

                        -m: only reedit files that have more that one
                            delta as compared to parent file.  New files
                            will be recreated with comment found in
                            active list.
                        -s: silent checkin

        $ME recheckout  Alias for reedit command.
        $ME reco        Alias for reedit command.

        $ME redelget [-m][-s] [file ...]
                        Similar to reedit but the file is checked in
                        when the command is done. This is the command to
                        use to collapse new files to their initial
                        1.1 delta (will assign comment in active list).
        $ME recheckin   Alias for redelget command.
        $ME reci        Alias for redelget command.

        $ME delete [-f] [file ...]
                        Delete one or more files from the workspace.
                        Will delete all files in active list if no file
                        args.  Note, for files brought over from parent,
                        this command actually moves the file under the
                        deleted_files/ subdir so it can be recovered.
                        For new files this command can remove the file
                        and file history completely.
                        (Updates active list if file is in there.)
                        -f : force delete regardless of warnings 
                             (non-interactive)

                             Warning, this will completely remove new
                             files from the workspace.  Will backup
                             if wx files newer than last backup.
        $ME rm          Alias for delete command.

        $ME mv file newfile     
                        Rename file to newfile
                        (Updates active list with new file name)
        $ME mv file newdir      
        $ME mv dir newdir       
                        Renames dir or file to newdir.  If newdir exists
                        then dir will be subdir under newdir.  Note,
                        this renames all files in dir and can take a
                        while if there are a lot of files affected by
                        the rename.  (Updates active list)

        $ME reset [-f] [file ...]
                        Resets file contents and history to that of
                        parent file.  If the file was renamed locally it
                        will be renamed to that of the parent.  It does not
                        work on new files (see uncreate or delete).

                        NOTE: use with care.  If something goes wrong,
                        do a wx restore from the last backup and copy
                        wx/tmp/nametable.orig to Codemgr_wsdata/nametable.

======================== Teamware Commands ======================
        $ME putback [-v][-f][-N][Teamware putback flags, see below][file ...]
                        Use Teamware putback command to putback either
                        file(s) specified or *all* active and renamed
                        files if no file(s) specified.  Will use pbcom
                        output as the putback comments. 
                        -f: force non-interactive mode (will not prompt)
                        -v: pass comments verbatim to putback(see pbcom)
                        -N: don't check bug synopsis against bug database
                        Accepts -n, -p pws, -q putback flags ('man putback' 
                        for more info).
        $ME pb          alias for putback.

        $ME resolve [Teamware resolve args]
                        resolve bringover conflicts and reedit merged 
                        files.  See 'man resolve' for args.

======================== ON Rules checking Commands ======================
        $ME cstyle      run cstyle over all active .c and .h files
                        skips files in wx/cstyle.NOT
        $ME jstyle      run jstyle over all active .java files
                        skips files in wx/jstyle.NOT
        $ME hdrchk      run 'hdrchk -a' over all active .h files
                        skips files in wx/hdrchk.NOT
        $ME makestyle   run makestyle over all active Makefiles
        $ME keywords    run keywords over all active files
                        skips files in wx/keywords.NOT
        $ME copyright   make sure there is a correct copyright message
                        that contains the current year
                        skips files in wx/copyright.NOT
        $ME cddlchk     make sure there is a current CDDL block in
                        active files
                        skips files in wx/cddlchk.NOT
        $ME rmdelchk    make sure sccs rmdel was not run on active files
                        (This causes Teamware problems.)
        $ME deltachk    make sure only 1 sccs delta in active files
                        (more than 1 breaks gate putback rules unless > 1
                        bug in putback.)
        $ME comchk      make sure comments are okay
        $ME rtichk      make sure RTI is approved for bugs/rfe's listed
                        in active list comments.  Will skip rtichk if
                        wx/rtichk.NOT exists.
        $ME outchk      warn if there are files checked out that aren't in
                        active list.
        $ME nits [file ...]
                        nits checking.  Run cstyle, jstyle, hdrchk, copyright,
                        cddlchk, and keywords over files to which they are
                        applicable (makestyle is not currently run
                        because it seems to be quite broken -- more
                        noise than data).  This is a subset of pbchk checks
                        suitable for checking files during development.
                        Use pbchk before doing the final putback.
                        Will run checks on all active files if no file args.
                        Will skip checks for files listed in wx/nits.NOT.
        $ME pbchk [file ...]
                        putback check.  Run cstyle, jstyle, hdrchk, copyright,
                        cddlchk, keywords, rmdelchk, deltachk, comchk, rtichk
                        and outchk over files to which they are
                        applicable (makestyle is not currently run
                        because it seems to be quite broken -- more
                        noise than data).  Good command to run before
                        doing a putback.  
                        Will run checks on all active files if no file args.
                        Will skip checks for files listed in wx/pbchk.NOT.

======================== Code Review Commands ======================
        $ME webrev [webrev-args]
                        generate webrev for active and renamed/deleted files.
                        Note, uses comments in the active list.  This is the
                        preferred way of reviewing code.  Arguments to webrev
                        may also be specified.
                        Will skip files listed in wx/webrev.NOT

        $ME codereview [-N] [codereview options]
                        generate environmentally friendly codereview diffs
                        for all active files.  -N indicates that delta
                        comments should not be included.

        $ME fullreview [-N] [codereview options]
                        generate full codereview diffs for all active files.
                        -N indicates that delta comments should not be
                        included.

======================== Backup and Restore Commands ======================
        $ME backup [-i|-n|-z|-b|-t]
                        make backup copies of all active and renamed files.
                        -i: info about backups (backup dir and contents)
                        -n: no compression 
                        -z: use gzip, faster than bzip2 but less compression.
                        -b: use bzip2, slower but better compression.
                        -t: backup if wx files are newer than last backup.
                        Defaults to the compression of the previous backup.
        $ME bu          Alias for backup command.

        $ME restore [-f] [backup_dir]   
                        restore a backup in a workspace (restores both
                        active files and performs file renames).  A path
                        to the directory containing the backup to
                        restore from can be optionally specified.
                        -f: non-interactive.  Will restore from last backup.

======================== Misc Commands ============================
        $ME apply <cmd> apply cmd to all active files; for example,
                        "$ME apply cat" cats every file
        $ME eval <cmd>  like apply, but more general.  In fact,
                        "$ME apply cmd" is implemented internally as
                        "$ME eval 'cmd \$file'".  When using eval,
                        you can refer to \$dir, \$file, \$filepath,
                        \$parent, and \$workspace.  For example:
                        $ME eval 'echo \$dir; sccs prt \$file | more'
                        will show the sccs history for each active file,
                        preceded by its directory.
        $ME grep        search all active files for pattern; equivalent to
                        "$ME eval 'echo \$filepath; grep pattern \$file'"
        $ME egrep       see $ME grep
        $ME sed         see $ME grep
        $ME nawk        see $ME grep

        $ME dir         echo the $ME directory path (\$workspace/$ME)
        $ME e <file>    edit the named $ME control file, e.g. "$ME e active".
                        The editor is \$EDITOR if set, else vi.

        $ME ea          shorthand for "$ME e active" (edit active list).  
                        Note, the format for each entry in the active
                        list is:

                        filepath
                        <empty line> # no spaces allowed
                        one or more comment lines # no blank lines between.
                        <empty line> # no spaces allowed, ends the entry.

                        In general, it is best to only edit the active
                        list to update comments.  Use the other $ME
                        commands like edit or create to update the
                        active list when possible.

        $ME ws <file>   cat the named workspace control file, i.e.
                        \$workspace/Codemgr_wsdata/file
        $ME args        shorthand for "$ME ws args"
        $ME access      shorthand for "$ME ws access_control"

        $ME help        print this usage message
        $ME version     print current version of this program
EOF
	exit 1
}

list_putback() {
	(wx_active; list_renamed -n)|nawk '!seen[$0]++'
}

list_new() {
	# list new files (not found in parent ws)
	typeset new

	if [[ $1 == '-t' ]]; then
		wx_active|
		while read new; do
			# thorough, skip new cache
			if ! lookup_parent $new; then
				# no parent, new file
				echo "$new"
			fi
		done
	else
		while read new; do
			# use new cache
			if ! lookup_parent $new; then
				# no parent, new file
				echo "$new"
			fi
		done < $wxdir/new
	fi
}

list_renamed() {
	typeset active current old

	if [[ $# -eq 0 ]]; then
		cat $wxdir/renamed
	elif [[ $1 == '-d' ]]; then
		# Only list only deleted file renames
		grep '^deleted_files/' $wxdir/renamed
	elif [[ $1 == '-n' ]]; then
		# Only list only current filenames
		cut -f1 -d' ' $wxdir/renamed
	elif [[ $1 == '-p' ]]; then
		# list parent for current instead of local previous name
		while read current old; do
			if lookup_parent $current; then
				print "$current $parentfile"
			else
				ring_bell
				print -u2 "Warning: cannot find parent file"\
					"for $current"
			fi
		done < $wxdir/renamed
	elif [[ $1 == '-a' ]]; then
		# Just list active renamed files
		for active in $(wx_active); do
			grep "^$(escape_re $active) " $wxdir/renamed
		done
	elif [[ $1 == '-r' ]]; then
		wx_active > $wxtmp/alist || fail "Error: cannot create $wxtmp/alist"
		# Just list non-active renamed files (just current name)
		while read current old; do
			grep -q "^$(escape_re $current)$" $wxtmp/alist ||
				echo $current
		done < $wxdir/renamed
		rm -f $wxtmp/alist
	else
		fail "Invalid flag $i. Run 'wx help' for info."
	fi
}

list_webrev() {
	# Output a list of active and renamed files suitable for webrev
	for filepath in $( (wx_active; list_renamed -n)|nawk '!seen[$0]++'); do
		if renamed; then
			echo "$filepath $parentfile"
		else
			echo "$filepath"
		fi
	done
}

wx_webrev() {
	typeset origdir=$PWD

	cd $workspace
	# skip files listed in .NOT files
	cat -s $wxdir/$command.NOT >$wxtmp/NOT

	( # do the loops in a subshell so there is only one file open
	for filepath in $(wx_active); do
		if grep -q "^$(escape_re $filepath)$" $wxtmp/NOT; then
			print -u2 "$filepath (skipping)"
			continue
		fi
		if renamed; then
			echo "$filepath $parentfile"
		else
			echo "$filepath"
		fi
		echo "\n$(wx_show_comment)\n"
	done

	# Do non-active renamed files
	for filepath in $(list_renamed -r); do
		if grep -q "^$(escape_re $filepath)$" $wxtmp/NOT; then
			print -u2 "renamed $filepath (skipping)"
			continue
		fi
		lookup_parent $filepath ||
			fail "Error: cannot find parent for $filepath."
		if [[ $filepath != $parentfile ]]; then
			echo "$filepath $parentfile"
			# output empty line, comment, empty line
			echo "\nRenamed only (webrev comment generated by "\
			    "$ME, not an sccs comment)\n"
		else
			echo "$filepath"
			echo "\nWarning, file in renamed list but has same "\
			    "name as parent (not an sccs comment)\n"
		fi
	done
	# End of subshell
	) > $wxtmp/webrev.list

	# Note that the file list must come last.
	${WXWEBREV:-webrev} -w "$@" $wxtmp/webrev.list

	cd $origdir
}

#
# list all active files
#
wx_active() {
	# do not print hash by default
	typeset rc hash=0

	case $1 in
		# list only renamed active files
		-r) list_renamed -a; return 0;;
		# list suitable for putback (both active and renamed)
		-p) list_putback; return 0;;
		# list suitable for webrev (both active and renamed)
		-w) list_webrev; return 0;;
		-*) fail "Invalid flag $1. See 'wx help' for more info.";;
	esac

        if [[ ! -r $wxdir/active ]]; then
                fail "Error: cannot read $wxdir/active"
        fi

	nawk '
	{
	    # skip blank lines
	    while (NF == 0) {
		    if (getline == 0)
			    next;
	    }
	    if (NF > 0){
		    # print the active filepath
		    print $1;
		    getline;
	    }
	    # skip blank lines
	    while (NF == 0) {
		    if (getline == 0){
			    # Error, corrupt active list (missing comment)
			    exit 1
		    }
	    }
	    # skip comment
	    while (NF > 0) {
		    if (getline == 0){
			    # Error, blank line after comment missing
			    exit 2
		    }
	    }
	}' $wxdir/active

	rc=$?
	if [[ $rc -eq 1 ]];then
		fail "Corrupt active list (missing comment)."
	elif [[ $rc -eq 2 ]];then
		fail "Corrupt active list (blank line needed after comment)."
	fi
}

#
# show the comment for $filepath
#
wx_show_comment() {
	if [[ -f $wxdir/active ]]; then
		nawk '
		{
			filename=$1
			getline
			while (getline) {
				if (length == 0)
					next
				if (filename == target) {
					if ($0 == "NO_COMMENT") {
							found = 0
							exit 1
					}
					found = 1
					print
				}
			}
		}
		END {
			if (found == 0)
				print "NO_COMMENT"
			exit 1 - found
		}' target=$filepath $wxdir/active
		return $?
	else
		echo "NO_COMMENT"
	fi
}

bugdb_lookup_monaco() {
	typeset buglist=$1
	typeset monaco=/net/monaco.sfbay/export/bin/monaco

	if [[ ! -x $monaco ]]; then
		return 1
	fi

	$monaco -text <<-EOF
	set What =
	substr(cr.cr_number, 1, 7), synopsis

	set Which =
	cr.cr_number in ($buglist)

	set FinalClauses =
	order by cr.cr_number

	do query/CR
	EOF
}

bugdb_compare() {
	nawk -v bugdb=$1 -v active=$2 -f - <<-"EOF"
	BEGIN {
		file = bugdb
		while (getline < file) {
			synbugdb[$1] = substr($0, length($1) + 1)
		}

		file = active
		while (getline < file) {
			synactive = substr($0, length($1) + 1)
			# If the synopsis doesn't match the bug database
			# and the synopsis isn't what's in the database
			# with " (something)" appended, spew a warning.
			if (!($1 in synbugdb)) {
				print "Bug " $1 " is not in the database"
			} else if (synbugdb[$1] != synactive &&
				!(index(synactive, synbugdb[$1]) == 1 &&
				  substr(synactive, length(synbugdb[$1])) ~ \
					/ \([^)]*\)$/)) {
				print "Synopsis of " $1 " is wrong:"
				print "  should be:" synbugdb[$1]
				print "         is:" synactive
			}
		}
	}
	EOF
}

#
# Summarize all comments listing, in order:
#	 - free-form comments
#	 - ARC case comments
#	 - Bug comments
#
# -a will suppress ARC case comments
# -b will suppress bug comments
# -n will do pbchk processing (give all warnings, no error exit)
# -o will suppress free-form (other) comments
# -p will do pbcom checking and exit if it finds problems unless -v is given
# -u will prevent sorting of the ARC case comments and bug comments
# -v will output all comments verbatim (no sorting)
# -N will prevent bug lookup, which may take a while.
#
# Note, be careful when modifying this function as sometimes the output
# should go to stdout, as in the case of being called via pbchk and
# sometimes the output should go to stderr.  Think about this when
# making changes in here.
#

function wx_summary {
	typeset i comment arc arcerr bug bugnospc bugid buglist synopsis \
		show_arcs=true \
		show_bugs=true \
		show_others=true \
		verbatim=false \
		pbchk=false \
		pbcom=false \
		cmd=sort \
		nolookup=false

	while getopts :abnopuvN i; do
		  case $i in
		  a)	show_arcs=false;;
		  b)	show_bugs=false;;
		  n)	pbchk=true;;
		  o)	show_others=false;;
		  p)	pbcom=true;;
		  v)	verbatim=true;;
		  u)	cmd=cat;;
		  N)	nolookup=true;;
		  *)	fail "Invalid flag -$OPTARG. See 'wx help' for more"\
		  		"info.";;
		  esac
	done

	# Store all the comments in a tmp file
	for filepath in $file_list; do
		wx_show_comment
	done | nawk '!seen[$0]++' > $wxtmp/comments

	if grep -q "^NO_COMMENT$" $wxtmp/comments; then
		print -u2 "Warning, found NO_COMMENT. Run '$ME ea' to edit the "\
			  "comments."
		if $pbcom; then
			# Don't want to output anything to stdout for a pbcom
			# if there is an error.
			return 1
		fi
	fi
	if $pbcom && $verbatim; then
		# All comments output verbatim.  Note, is hacky because
		# of the wx_summary interface.  pbcom calls wx_summary
		# with -po assuming other comments shouldn't be output.
		show_others=true
	fi

	# Note, hard tab in the arc regex.  This only recognizes FWARC,
	# LSARC and PSARC.  Also, regex must be compat with both egrep
	# and nawk.
	arc='(FW|LS|PS)ARC[\/ 	][12][0-9][0-9][0-9]\/[0-9][0-9][0-9][^0-9]'
	# bug ID must followed by single space
	bug='[0-9][0-9][0-9][0-9][0-9][0-9][0-9] '
	bugnospc='[0-9][0-9][0-9][0-9][0-9][0-9][0-9][^ ]'

	if $show_arcs; then
		# Note must use /usr/bin/sort.
		if ! egrep "^$arc" $wxtmp/comments |
			 sed 's#\([A-Z][A-Z]*ARC\)[/ 	]#\1 #' | sort |
			 /usr/bin/sort -cu -k 1,2 2>$wxtmp/error >/dev/null
		then
			arcerr=$(nawk '{match($0, '"/$arc/"'); \
				print substr($0, RSTART, RLENGTH);}' \
				$wxtmp/error)

			if $pbchk; then
				# if pbchk print to stdout
				print "Inconsistent ARC summaries for: $arcerr"
			else
				# else print to stderr
				print -u2 \
				"Inconsistent ARC summaries for: $arcerr"
			fi
			if $pbcom && ! $verbatim; then

				# Don't want to output anything to
				# stdout for a pbcom if there is an
				# error.

				return 1
			fi
		fi
	fi

	if $show_bugs; then
		# Treating bug comments with "(nit comment)" at the end as the
		# same as the original bug hence the sed and nawk below
		# Note hard tabs in sed arg.
		# Must use /usr/bin/sort.
		if ! grep "^$bug" $wxtmp/comments |sort|
			 sed 's/[ 	][ 	]*([^)]*) *$//' |
			 nawk '!seen[$0]++'|
			 /usr/bin/sort -cnu 2>$wxtmp/error >/dev/null; then
			if $pbchk; then
				print -n "Inconsistent bug summaries for: "
				sed 's#^[^0-9]*\('"${bug}"'\).*#\1#' \
				    $wxtmp/error
			else
				print -nu2 "Inconsistent bug summaries for: "
				sed 's#^[^0-9]*\('"${bug}"'\).*#\1#' \
				    $wxtmp/error >&2
			fi
			if $pbcom && ! $verbatim; then
				# Don't want to output anything to
				# stdout for a pbcom if there is an
				# error.
				return 1
			fi
		fi

		# Compare bug synopsis in active comments with the bug database.
		# If we've been passed -N, then we just never set buglist, thus
		# skipping the lookup.
		if ! $nolookup; then
			grep "^$bug" $wxtmp/comments | sort > $wxtmp/buglist.active
			cat $wxtmp/buglist.active | while read bugid synopsis; do
				buglist=$buglist,$bugid
			done
			buglist=${buglist#,}
		else
			if $pbchk; then
				print "Not performing bug synopsis check (be careful)"
			else
				print -u2 "Not performing bug synopsis check (be careful)"
			fi
		fi
		if [[ -n $buglist ]]; then
			bugdb_lookup_monaco $buglist > $wxtmp/buglist.bugdb
			if [[ -s $wxtmp/buglist.bugdb && $? -eq 0 ]]; then
				bugdb_compare $wxtmp/buglist.bugdb \
					$wxtmp/buglist.active > $wxtmp/error
				if [[ -s $wxtmp/error ]]; then
					if $pbchk; then
						cat $wxtmp/error
					else
						cat $wxtmp/error >&2
					fi
					if $pbcom && ! $verbatim; then
						# Don't want to output anything
						# to stdout for a pbcom if there
						# is an error.
						return 1
					fi
				fi
			else
				if $pbchk; then
					print "Could not perform bug synopsis check"
				else
					print -u2 "Could not perform bug synopsis check"
					if $pbcom; then
						print -u2 "Use -N to skip bug synopsis check (be careful)"
					fi
				fi
				if $pbcom && ! $verbatim; then
					# Don't want to output anything
					# to stdout for a pbcom if there
					# is an error.
					return 1
				fi
			fi
		fi

		if egrep "^$bugnospc" $wxtmp/comments >$wxtmp/error; then
			# must have single space following bug ID
			if $pbchk; then
				print "\nThese bugs are missing single space following the bug ID"
				print "(output prefaced by active file line number ':'):"
				while read comment
				do
					grep -n "^$comment" $wxdir/active
				done < $wxtmp/error
			else
				print -u2 "\nThese bugs are missing single space following the bug ID"
				print -u2 "(output prefaced by active file line number ':'):"
				while read comment
				do
					grep -n "^$comment" $wxdir/active >&2
				done < $wxtmp/error
			fi
			if $pbcom && ! $verbatim; then
				# Don't want to output anything to
				# stdout for a pbcom if there is an
				# error.
				return 1
			fi
		fi
	fi

	# Create warning for pbchk or pbcom.
	if $pbchk || ($pbcom && ! $verbatim) &&
		egrep -v "^($bug|$bugnospc|$arc|NO_COMMENT$)" $wxtmp/comments\
				> $wxtmp/other_comments; then
		cat <<-EOF
Warning, the following comments are found in your active list
that are neither bug or arc cases: 

		EOF
		cat $wxtmp/other_comments
		print -- "\n---- End of active list comment warnings ----"
	fi > $wxtmp/comment_warning

	if [[ -s $wxtmp/comment_warning ]]; then
		if $pbchk; then
			# output to stdout, don't exist in case there are more
			# warnings.
			cat $wxtmp/comment_warning
		elif $pbcom && ! $verbatim ; then
			# Don't want to output anything to stdout for a pbcom
			# if there is an error.
			cat $wxtmp/comment_warning >&2
			return 1
		fi
	fi

	if $pbchk; then
		cd $workspace
		# See if sccs delta comment is the same as active list comment
		for filepath in $file_list; do
			# extract most recent delta comment
			sccs prs -d ':C:' $filepath | sort > $wxtmp/com1 ||
				fail "sccs prs -d ':C:' $filepath failed."

			# Add blank line to active comments so following cmp will
			# work properly.
			(wx_show_comment; print) | sort > $wxtmp/com2

			if ! cmp -s $wxtmp/com1 $wxtmp/com2; then
				print "\n$filepath"
				print "Warning: current sccs comment does not"\
					"match active list comment"
				print "(< sccs comment, > active list comment):"
				diff $wxtmp/com1 $wxtmp/com2
			fi
		done
		# Just output warnings for pbchk
		return 0
	fi

	if $show_others; then
		  if ! $verbatim; then
			  # The non-verbatim check should have produced the
			  # other_comments file.
			  cat $wxtmp/other_comments| $cmd
		  else
			  # just output comments verbatim then return
			  cat $wxtmp/comments
			  return 0
		  fi
	fi

	if $show_arcs; then
		  egrep "^$arc" $wxtmp/comments | $cmd
	fi

	if $show_bugs; then
		  egrep "^$bug" $wxtmp/comments | $cmd
	fi
	return 0
}

update_renamed_file() {
	# Try to add a entry to the renamed list.  Note, this stores the new
	# name and previous name, not the  parent name as this is more useful in
	# detecting cyclic renames.

	# ofp: old filepath, nfp: new filepath
	typeset ofp=$1 nfp=$2

	# remove old and new entries from renamed
	egrep -v "^($(escape_re $ofp)|$(escape_re $nfp)) " $wxdir/renamed \
		>$wxtmp/renamed
	[[ ! -f $wxtmp/renamed ]] && fail "Error: cannot create $wxtmp/renamed"
	mv -f $wxtmp/renamed $wxdir/renamed || \
		fail "Error: cannot create $wxdir/renamed."

	# remove old entries from local nt cache
	remove_local_nt_entry $ofp

	# Do not update renamed list if the filepath is the same as
	# the parent or the file is new.
	if lookup_parent $nfp; then
		if [[ $parentfile != $nfp ]]; then
			print "$nfp $ofp" >> $wxdir/renamed || \
				fail "Error: cannot append $wxdir/renamed."

			[[ $ACTSORT == sort ]] && do_renamed_sort=true
		fi
	fi
	return 0
}

update_renamed_dir() {
	typeset append pb_files new orig
	typeset -i rc

	if [[ $# -eq 0 ]]; then
		# No args so we need to create the renamed list from
		# the source root.
		append=false
		if [ -r $wxdir/srcroot_dir ]; then
			pb_files=$(cat $wxdir/srcroot_dir)
		else
			pb_files=$DEFAULT_SRCDIR
		fi
	else
		# Assuming one or more filepaths as args
		append=true
		pb_files="$*"
	fi
	echo "Updating $ME renamed list... this may take several minutes."

	# Get output of putback -n to detect renames elsewhere in
	# this script.

	get_pb_output $pb_files

	nawk '
		/^rename from:/{orig_file=$3}
		$1 == "to:" {print $2 " " orig_file}' \
		$wxtmp/putback.out  >$wxtmp/pb_renames || \
			fail "Error, creation of $wxtmp/pb_renames failed."

	cp $wxdir/renamed $wxdir/renamed.old ||
		fail "Error: cannot create $wxdir/renamed.old."

	if $append; then
		nawk '!seen[$0]++' $wxtmp/pb_renames $wxdir/renamed \
			> $wxtmp/renamed || \
			fail "Error: cannot create $wxtmp/renamed."
		mv -f $wxtmp/renamed $wxdir/renamed || \
			fail "Error: cannot create $wxdir/renamed."
	else
		mv -f $wxtmp/pb_renames $wxdir/renamed ||
			fail "Error: cannot create $wxdir/renamed."
	fi

	[[ $ACTSORT == sort ]] && do_renamed_sort=true
}

# returns 0 if a pattern in patternfile matches input path arg
pathcheck() {
	typeset pattern path=$1 patternfile=$2

	while read pattern; do
		if [[ $path == $pattern ]]; then
			return 0 # pattern matched path
		fi
	done < $patternfile
	return 1 # file path not matched by pattern
}

#
# Evaluate a command for all listed files.  This is the basic building
# block for most wx functionality.
#

wx_eval() {
	typeset -i changedir=1

	if [[ $# -gt 1 && "$1" == "-r" ]]; then
		changedir=0
		shift
	fi

	pre_eval=$*
	# skip files listed in .NOT files
	cat -s $wxdir/$command.NOT >$wxtmp/NOT
	for filepath in $file_list; do
		if pathcheck $filepath $wxtmp/NOT; then
			print "$filepath (skipping)"
		else
			cd $workspace
			dir=`dirname $filepath`
			file=`basename $filepath`
			[[ $changedir -eq 1 ]] && cd $dir
			eval $pre_eval
		fi
	done
}

#
# Initialize a workspace for wx.
#

wx_init() {
	typeset srcroot_dir force=false

	# check that srcroot is relative to top of workspace
	if cd $workspace/$1; then
		# normalize the srcroot dir for test below
		srcroot_dir=$(/bin/pwd)
		srcroot_dir="${srcroot_dir#$workspace/}"
		if [[ $srcroot_dir == $workspace ]]; then
			# Special case need to set srcroot_dir to
			# a relative path but we're at the top of the
			# workspace.
			srcroot_dir="."
		fi
	else
		fail "Source root '$1' does not exist in workspace"\
			"($workspace)."
	fi

	if [ -d $wxtmp ]; then
                if [[ $2 != -f[nqt] ]]; then
                        echo "This workspace has already been initialized."
                        ok_to_proceed 'Do you really want to re-initialize?'
                fi
	else
		mkdir -p $wxtmp
	fi

	#
	# Make sure to save $srcroot_dir as a path relative to the workspace
	# root; an absolute path would break if the workspace name changed.
	#
	rm -f $wxdir/srcroot_dir
	echo $srcroot_dir >$wxdir/srcroot_dir

	backup_dir=$HOME/$ME.backup/$workspace_basename
	[[ -d $backup_dir ]] || mkdir -p $backup_dir ||
		fail "mkdir -p $backup_dir failed."
	cd $backup_dir
	rm -f $wxdir/backup_dir
	pwd >$wxdir/backup_dir || fail "Creation of  $wxdir/backup_dir failed."

	touch $wxdir/renamed
	touch $wxdir/active
	touch $wxdir/new
	touch $wxdir/local_nametable

	if [[ -z "$2" ]]; then
		# Interactive mode
		cat << EOF
    Pick one of the following update methods:

    1) Thorough: Detect any differences between the current workspace
       and its parent and update the active, new and renamed lists.  Use
       this in workspaces where files have been renamed or deleted or
       there are files that are different from the parent that are not
       checked out.  Note, files must be under SCCS control in order for
       this method to compare them to the parent workspace.

    2) Quick: Only update the active list with files that are currently
       checked out.  Will not update the renamed list.

    3) None: Use this on workspaces where there are no changes between
       the workspace and its parent.  This is very quick but will not
       update the active, new or renamed lists.

EOF
		read answer?"Which update method? [1|2|3]: "
		case $answer in
			1) wx_update;;
			2) wx_update -q;;
			3) ;;
			*) fail "Bad answer: ${answer}. Rerun init command"\
				"again";;
		esac
		yesno "Keep active list sorted by default?"
		if [[ "$answer" == 'yes' ]]; then
			print "true" > $wxdir/sort_active
		else
			print "false" > $wxdir/sort_active
		fi
	else
		# non-interactive mode
		case $2 in
			# forced thorough update
			-ft) wx_update; force=true;;
			# forced quick update
			-fq) wx_update -q; force=true;;
			# forced no update
			-fn) force=true;;
			# invalid arg
			-*) fail "$ME $command: unrecognized argument";;
		esac
		if [[ $3 == -s ]]; then
			print "true" > $wxdir/sort_active
		else
			print "false" > $wxdir/sort_active
		fi
	fi
	print

	if [ -s $wxdir/active ]; then
		basedir=$workspace
		file_list=`wx_active`
		if $force; then
			# only backup if necessary
			print "Will backup wx and active files if necessary"
			wx_backup -t
		else
			print "Making backup copies of all wx and active files"
			wx_backup
		fi
	else
		echo "Active list empty, not doing backup."
		echo
	fi

	echo "$ME initialization complete"
}

#
# Find all checked out files
#

wx_checked_out() {
	typeset origdir=$(pwd)
	cd $workspace
	x=$(ls -t $wsdata/nametable $wxdir/sccs_dirs 2>/dev/null)
	if [[ -z $x || "`basename $x`" == nametable ]]; then
		if [ -f $wxdir/srcroot_dir ]; then
			srcroot_dir=`cat $wxdir/srcroot_dir`
		else
			srcroot_dir=$DEFAULT_SRCDIR
		fi
		print -u2 "Workspace nametable changed: sccs_dirs out of date"
		print -u2 "Updating $wxdir/sccs_dirs...this may take a few minutes.\n"
		rm -f $wxdir/sccs_dirs
		find $srcroot_dir -name SCCS -print | sort >$wxdir/sccs_dirs
	fi
	cd $workspace
	rm -f $wxtmp/checked_out
	# Note if srcroot_dir = . this must be removed from the front of the
	# filepaths.
	echo $(sed -e 's,$,/p.*,' $wxdir/sccs_dirs) | \
		tr \\040 \\012 | \
		grep -v '*' | \
		sed -e 's,SCCS/p.,,' |sed -e 's,^\./,,' >$wxtmp/checked_out
	cd $origdir
}

deal_ws_renames() {
	# See if any active/renamed files were renamed externally
	# (perhaps by bringover?) and try to rename the active entry
	# filepath.
	typeset fp newfp renamed localfile hash1 hash2 hash3 hash4 \
		notrenamed_list origdir=$(pwd)
	cd $workspace
	list_putback |\
	while read fp; do
		if [[ ! -f $fp ]]; then
			# file not found, suspect rename.
			# using renamed for error checking.
			renamed=false
			# search cached local nt to find old hash info
			grep "^$(escape_re $fp) " $wxdir/local_nametable |\
			while read localfile hash1 hash2 hash3 hash4; do
				# find new filepath
				newfp=$(fgrep " $hash1 $hash2 $hash3 $hash4"\
					$wsdata/nametable|cut -f1 -d' ')

				[[ -z $newfp ]] && continue

				if [[ $newfp != $fp ]]; then
					update_renamed_file $fp $newfp
					rename_active_entry $fp $newfp
					echo "\nRenamed active file"\
						"$fp to $newfp"
					renamed=true
					break
				fi
			done
			if ! $renamed; then
				if [[ -z $notrenamed_list ]]; then
					notrenamed_list="$fp"
				else
					notrenamed_list="$notrenamed_list\n$fp"
				fi
			fi
		fi
	done
	if [[ -n $notrenamed_list ]]; then
		ring_bell
		cat <<-EOF
Warning, active file(s):
   $(echo $notrenamed_list)
not found and cannot be renamed.  Use "$ME ea" to edit the active list to
remove these entries if they do not exist in this workspace.
		EOF
	fi
	cd $origdir
}

#
# Old style update the active file list (by appending all checked out files).
# This is what the original wx update did.
#
wx_update_quick() {

	# Sort active if requested.
	[[ "$1" == "-s" ]] && ACTSORT=sort

	wx_checked_out
	cd $wxdir
	rm -f tmp/files.old tmp/files.new active.new
	wx_active >tmp/files.old || fail "Error: cannot create $wxtmp/files.old"
	# sed has a hard tab, used to delete lines containing only whitespace
	sed '/^[	 ]*$/d' tmp/files.old tmp/checked_out|
		nawk '!seen[$0]++' | $ACTSORT > tmp/files.new ||
			fail "Error: cannot create $wxtmp/files.new"
	cp -f new new.old || fail "Error: cannot create new.old."
	while read filepath ; do
		add_local_nt_entry $filepath
		(echo "$filepath"; echo; wx_show_comment; echo)
	done < tmp/files.new > active.new ||
		fail "Error: cannot create $wxdir/active.new"

	mv -f active active.old
	mv -f active.new active

	echo
	echo "New active file list:"
	echo
	cat tmp/files.new
	echo
	echo "Diffs from previous active file list:"
	echo
	${WXDIFFCMD:-diff} tmp/files.old tmp/files.new
	echo "End active diffs =========================="

	# Do new file processing after active list is updated.

	# Note, the parent nt read check below is hackish because we are
	# assuming that lookup_parent needs to read the parent nt and if it
	# can't then we want to just issue the warning.
	if [[ -n $parent && ! -r $parent/Codemgr_wsdata/nametable ]]; then
		echo "\nWarning: cannot read parent nametable, new file list"\
			"not output." >&2
	else
		while read filepath; do
			# lookup_parent populates local nt cache
			if lookup_parent $filepath; then
				remove_new $filepath
			else
				add_new $filepath
			fi
		done < tmp/files.new

		echo
		echo "New new-file list:"
		echo
		cat new
		echo
		echo "Diffs from previous new-file list:"
		echo
		${WXDIFFCMD:-diff} new.old new
		echo "End new diffs =========================="
	fi
}

#
# Update various lists (active, renamed, new)
#

wx_update() {
	typeset i efp sortarg do_quick=false
	typeset -i rc found
	# default, update all lists
	typeset update_active=true update_renamed=true update_new=true

	while getopts :qrs i; do
		  case $i in
		  q)	do_quick=true;;
		  r)	update_active=false
			update_new=false;;
		  s)	ACTSORT=sort; sortarg="-s";;
		  *)	fail "Invalid flag -$OPTARG. See 'wx help' for more"\
		  		"info.";;
		  esac
	done

	deal_ws_renames

	if $do_quick; then
		# Do old school wx update (only for checked out files)
		# This is faster but not as thorough.
		wx_update_quick $sortarg
		return
	fi

	if [[ -z $parent ]]; then
		fail "Error: cannot do thorough update, no parent.  Use 'update -q'"\
			"instead."
	fi
	if [[ ! -r $parent/Codemgr_wsdata/nametable ]]; then
		fail "Error: cannot read $parent/Codemgr_wsdata/nametable"
	fi

	# create tmp/checked_out file which putback -n may not list.
	# Do this before putback so it doesn't unnecessarily update the
	# sccs dirs cache.
	wx_checked_out

	# Get output of putback -n to detect renames and active files.
	if [ -f $wxdir/srcroot_dir ]; then
		get_pb_output $(cat $wxdir/srcroot_dir)
	else
		get_pb_output $DEFAULT_SRCDIR
	fi

	cd $wxdir

	if $update_renamed; then
		if [[ -f renamed ]]; then
			mv renamed renamed.old ||
			    fail "Error: cannot create $wxdir/renamed.old."
		else
			touch renamed.old ||
			    fail "Error: cannot create $wxdir/renamed.old."
		fi

		nawk '  /^rename from:/{orig_file=$3}
			$1 == "to:" {print $2 " " orig_file}' \
			tmp/putback.out |$ACTSORT > tmp/renamed ||\
				fail "Error, creation of $wxdir/tmp/renamed failed."
			mv -f tmp/renamed renamed || \
				fail "Error: cannot create $wxdir/renamed"

		for filepath in $(cut -f1 -d' ' renamed); do
			add_local_nt_entry $filepath
		done

		echo "New renamed file list:"
		echo
		cat renamed
		echo
		echo "Diffs from previous renamed file list:"
		echo
		${WXDIFFCMD:-diff} renamed.old renamed
		echo "End renamed diffs =========================="
	fi

	if $update_active; then
		# Create active list from putback output.
		nawk '/^(update|create): / {print $2};
		     /^The following files are currently checked out/ \
			{p=1; continue};
		     /^"/ {continue};
		     NF == 0 {p=0; continue};
		     {if (p==1)
		     	print $1}' tmp/putback.out |
		     sort -u > tmp/active_nawk_out ||
		     fail "Error: cannot create $wxtmp/active_nawk_out"

		# list files in conflict also
		nawk '/^(conflict): / {print $2}' tmp/putback.out |
		    sort -u > tmp/conflict_nawk_out ||
		    fail "Error: cannot create $wxtmp/conflict_nawk_out"

		# Need to read $wsdata/nametable if there are conflicts
		if [[ -s tmp/conflict_nawk_out && ! -r $wsdata/nametable ]]
		then
			fail "Error: cannot read $wsdata/nametable."
		fi

		# clear the tmp active file
		print -n > tmp/active.new || fail "Error: cannot create tmp/active.new."

		# store current active list
		wx_active > tmp/files.old ||
			fail "Error: cannot create $wxtmp/files.old"

		# go through all the possible active files (keeping the existing
		# ones as well). Note hard tab in sed arg.
		for filepath in $(sed '/^[	 ]*$/d' tmp/files.old \
			tmp/checked_out tmp/conflict_nawk_out \
			tmp/active_nawk_out | nawk '!seen[$0]++' | $ACTSORT); do

			efp=$(escape_re $filepath)

			if grep -q "^$efp$" tmp/conflict_nawk_out; then

				# conflict files have a parent but the
				# putback output only shows the parent's
				# filename, need to find local name in
				# case of rename

				grep "^$efp " $parent/Codemgr_wsdata/nametable|\
					read localfile hash1 hash2 hash3 hash4
				local_file="$(\
				    fgrep " $hash1 $hash2 $hash3 $hash4" \
					$wsdata/nametable | cut -f1 -d' ')"

				# continue if empty string
				[[ -z "$local_file" ]] && continue

				if ! grep -q "^$local_file" tmp/active.new; then
					filepath=$local_file
				else
					continue
				fi
			fi
			add_local_nt_entry $filepath
			(echo $filepath; echo; wx_show_comment; echo)\
			    >> tmp/active.new
		done

		rm -f tmp/active_nawk_out

		mv -f active active.old
		mv -f tmp/active.new active
		wx_active > tmp/files.new

		echo
		echo "New active file list:"
		echo
		cat tmp/files.new
		echo
		echo "Diffs from previous active file list:"
		echo
		${WXDIFFCMD:-diff} tmp/files.old tmp/files.new
		echo "End active diffs =========================="
		rm -f tmp/files.old tmp/files.new

	fi

	# The new list is for caching names of new files to speed up commands
	# that list the new files.
	if $update_new; then
		if [ -f new ]; then
			cp -f new new.old || fail "Error: cannot create file new.old."
		elif [ ! -f new.old ]; then
			touch new.old || fail "Error: cannot create file new.old."
		fi
		# Create new list from putback output.
		nawk '/^create: / {print $2};' tmp/putback.out |
			sort -u > tmp/new || fail "Error: cannot create $wxtmp/new."
		mv -f tmp/new new
		echo
		echo "New new-file list:"
		echo
		cat new
		echo
		echo "Diffs from previous new-file list:"
		echo
		${WXDIFFCMD:-diff} new.old new
		echo "End new diffs =========================="
	fi
}

wx_edit() {
	# Must be called via wx_eval
	if [ -f SCCS/p.$file ]; then
		echo "$filepath already checked out"
		update_active $filepath
	elif [ -f $file ]; then
		echo $filepath
		if sccs edit $silent $file; then
			update_active $filepath
		else
			fail "sccs edit $filepath failed."
		fi
	else
		ring_bell
		echo "Warning. file $filepath not found."
	fi

	[[ $ACTSORT == sort ]] && do_active_sort=true
}

wx_unedit() {
	# Must be called via wx_eval
	typeset -i force=0
	typeset arg msg

	# set positional args to contents of global $args
	set -- $args

	while getopts :f arg; do
		case $arg in
			 f) force=1;;
			 *) fail "Invalid flag -$OPTARG. See 'wx help' for"\
			 	"more info.";;
		esac
	done

	msg="differs from parent file, will remain in active list."

	if [[ ! -f SCCS/p.$file ]]; then
		echo "$filepath not checked out"
	else
		if [[ $backup_done -eq 0 ]]; then
			if [[ $force -eq 0 ]]; then
				yesno "Do you want to backup files first?"
				if [[ "$answer" == "yes" ]]; then
					wx_backup || fail "Backup failed."
				fi
			else
				# only backup if necessary
				print "Will backup wx and active files if necessary"
				wx_backup -t || fail "Backup failed."
			fi
			backup_done=1;

			# cd to the dir where the file is in case
			# wx_backup took us somewhere else.

			cd ${workspace}/$dir
		fi

		echo $filepath
		if sccs unedit $silent $file; then
			if [[ $force -eq 1 ]]; then
				if is_active $filepath; then
					if wx_pnt_filepath $filepath; then
						if cmp -s $file $parentfilepath; then
							remove_active_entry $filepath
						else
							print "$filepath $msg"
						fi
					fi
				fi
			else
				ask_remove_active_entry
			fi
		fi
	fi
}

wx_create() {
	# Must be called via wx_eval
	typeset -i checkout=0 force=0
	typeset arg

	while getopts :fo arg; do
		case $arg in
			 o) checkout=1;;
			 f) force=1;;
			 *) fail "Invalid flag -$OPTARG. See 'wx help' for"\
			 	"more info.";;
		esac
	done

	if [ ! -f $file ]; then
		ring_bell
		echo "Error! $filepath is not a file."
		return 1
	elif [ -f $workspace/deleted_files/$filepath ]; then
		ring_bell
		cat >&2 <<-EOF
Error: a deleted version of $filepath exists.
You must undelete the file and edit that version.
Run:
'cd $workspace'
'$ME mv deleted_files/$filepath $filepath'
'$ME edit $filepath'
		EOF
		return 1
	elif [[ -n $parent && -f $parent/$filepath ]]; then
		ring_bell
		cat >&2 <<-EOF
Error! $filepath exists in the parent workspace $parent.
Choose a different name.
		EOF
		return 1
	elif [[ -n $parent && -f $parent/deleted_files/$filepath ]]; then
		ring_bell
		cat >&2 <<-EOF
Error! a deleted version of $filepath exists in the parent workspace
You must undelete the file and edit that version.
Run:
'cd $workspace'
'bringover deleted_files/$filepath'
'$ME mv deleted_files/$filepath $filepath'
'$ME edit $filepath'
		EOF
		return 1
	elif [ -f SCCS/s.$file ]; then
			echo "$filepath already created, active list not"\
				"updated." >&2
	else
		# XXX it would be nice if keyword would work on new files
		if ! egrep "$SCCSKEYWORD" $file >/dev/null; then
			ring_bell
			cat >&2 <<-EOF

Warning!!!
$filepath 
is missing SCCS keywords.  See
/net/wizard.eng/export/misc/general_docs/keyword_info.txt
for more info.  Note, pay attention to the tabs.
			EOF
			if [[ $force -ne 1 ]]; then
				yesno "Continue with create?"
				if [[ "$answer" != 'yes' ]]; then
					echo "Aborting create $filepath"
					return 1
				fi
			fi
		fi

		if ! copyrightchk $file; then
			# Sound bell
			ring_bell
			cat >&2 <<-EOF

Warning!!!
$filepath 
has copyright problems.  See
/net/wizard.eng/export/misc/general_docs/golden_rules.txt
for more info.
			EOF
			if [[ $force -ne 1 ]]; then
				yesno "Continue with create?"
				if [[ "$answer" != 'yes' ]]; then
					echo "Aborting create $filepath"
					return 1
				fi
			fi
		fi

		if ! cddlchk -a $file; then
			# Sound bell
			ring_bell
			cat >&2 <<-EOF

Warning!!!
$filepath 
has CDDL block problems.  See
http://www.opensolaris.org/os/community/onnv/devref_toc/devref_7/#7_2_3_nonformatting_considerations
for more info.
			EOF
			if [[ $force -ne 1 ]]; then
				yesno "Continue with create?"
				if [[ "$answer" != 'yes' ]]; then
					echo "Aborting create $filepath"
					return 1
				fi
			fi
		fi

		if [[ ! -d SCCS ]]; then
			mkdir SCCS || fail "Error: cannot create SCCS dir."
		fi

		if [[ -n "$comment_file" ]]; then
			sccs create $silent -y"$(\
			    sed '/^[ 	]*$/d' $comment_file)" $file ||
				    fail "sccs create $filepath failed."
		else
			sccs create $silent $file ||
				fail "sccs create $filepath failed."
		fi
		rm -f ,$file
		update_active $filepath
		add_new $filepath
		if [[ $checkout -eq 1 ]]; then
			sccs edit $silent $file ||
				fail "sccs edit $filepath failed."
		fi
		[[ $ACTSORT == sort ]] && do_active_sort=true
	fi
}

wx_uncreate() {
	# Must be called via wx_eval
	# undoes a 'wx create'

	typeset efp
	typeset -i force=0

	case $1 in
		-f) force=1;;
		-*) fail "$ME $command: unrecognized argument";;
	esac

	if [[ $backup_done -eq 0 ]]; then
		if [[ $force -eq 0 ]]; then
			yesno "Do you want to backup files first?"
			if [[ "$answer" == 'yes' ]]; then
				wx_backup || fail "Backup failed."
			fi
		else
			# only backup if necessary
			print "Will backup wx and active files if necessary"
			wx_backup -t || fail "Backup failed."
		fi
		backup_done=1;
		cd $workspace/$dir
	fi

	if [[ ! -f $file ]]; then
		echo "$filepath not found, skipping"
		return 1
	fi

	efp=$(escape_re $filepath)

	if ! wx_pnt_filepath; then
		# This is a new file so let's uncreate it.
		answer='no'
		if [[ $force -ne 1 ]]; then
			cat <<-EOF

$filepath appears to be a new file.  
Note, $command will remove its SCCS info from your
workspace and entry in the active list but will leave
the file in your workspace.  

			EOF
			# yesno sets answer
			yesno "Continue $command $filepath?"
		else
			# forced to yes
			answer='yes'
		fi

		if [[ "$answer" == 'yes' ]]; then
			if [[ ! -f SCCS/p.$file ]]; then
				sccs edit $file ||
				    fail "sccs edit $filepath failed."
			fi
			rm -f SCCS/s.$file SCCS/p.$file
			# For later cleanup on exit
			if grep -q "^$efp " $wsdata/nametable 2>/dev/null; then
				NEED_WS_CLEAN='y'
			fi

			if is_active $filepath; then
				remove_active_entry $filepath
			fi
			remove_new $filepath
		else
			echo "skipping $filepath"
		fi
	else
		echo "Not new, skipping $filepath"
	fi # if ! wx_pnt_filepath
}

wx_reset() {
	# Must be called via wx_eval
	# resets a local file to the parent version

	typeset efp
	typeset -i force=0

	case $1 in
		-f) force=1;;
		-*) fail "$ME $command: unrecognized argument";;
	esac

	if [[ $backup_done -eq 0 ]]; then
		if [[ $force -eq 0 ]]; then
			yesno "Do you want to backup files first?"
			if [[ "$answer" == 'yes' ]]; then
				wx_backup || fail "Backup failed."
			fi
		else
			# only backup if necessary
			print "Will backup wx and active files if necessary"
			wx_backup -t || fail "Backup failed."
		fi
		backup_done=1;
	fi

	if [[ ! -f $file ]]; then
		print "$filepath not found, skipping"
		return 1
	fi

	efp=$(escape_re $filepath)

	if wx_pnt_filepath; then
		if [[ $force -ne 1 ]]; then
			answer='no' # safe default
			cat <<-EOF

Regarding: $filepath
$command will reset the file contents and sccs history to that of the parent:
$parentfilepath
and remove the entry from the active and renamed lists.

			EOF
			if [[ $filepath != $parentfile ]]; then
				print "Note: local file will be reset to parent filepath."
			fi
			# yesno sets answer
			yesno "Continue $command $filepath?"
		else
			# forced to yes
			answer='yes'
		fi

		if [[ "$answer" == 'yes' ]]; then
			if is_active $filepath; then
				remove_active_entry $filepath
			fi
			if renamed; then
				remove_renamed_entry $filepath
			fi
			rm -f $file SCCS/[ps].$file
			grep -v "^$efp " $wsdata/nametable > $wxtmp/nametable.new || \
				fail "Error: cannot create $wxtmp/nametable.new ."
			mv -f $wxtmp/nametable.new $wsdata/nametable || \
				fail "Error: mv -f $wxtmp/nametable.new $wsdata/nametable failed."

			# add to bringover list for more efficient bringover
			bofilelist="$bofilelist $parentfile"
		else
			print -u2 "Skipping $filepath"
		fi
	else
		cat >&2 <<-EOF

Warning: skipping $filepath 
as it appears to be new. Use 'uncreate' to remove this new file from the
workspace.
		EOF
	fi # if ! wx_pnt_filepath
}


cyclic_rename() {
	# Detect the cyclic rename that causes Teamware problems.
	# See 'man workspace' for more info
	typeset new_filepath=$1 old_filepath=$2\
		found_new=false found_old=false
	typeset prev_new prev_old

	while read prev_new prev_old; do
		if [[ "deleted_files/$new_filepath" == $prev_new &&
			  $old_filepath != $prev_new ]]; then

			# Cyclic rename
			return 0
		fi

		if [[ $new_filepath == $prev_old && $prev_new != $old_filepath ]]
		then
			# The new file was the old file of a previous rename
			found_new=true
			if $found_old; then
				# Cyclic rename
				return 0
			fi
		elif [[ $old_filepath == $prev_new &&
		    $new_filepath != $prev_old ]]; then

			# The old filepath was the new filepath of a
			# previous rename and this rename is not an undo
			# (new filepath is diff from previous old
			# filepath)

			found_old=true
			if $found_new; then
				# Cyclic rename
				return 0
			fi
		fi
	done < $wxdir/renamed

	# Not a cyclic rename
	return 1
}

wx_delete() {
	# Must be called via wx_eval
	typeset efp
	typeset -i force=0

	case $1 in
		-f) force=1;;
		-*) fail "$ME $command: unrecognized argument";;
	esac

	if [[ $backup_done -eq 0 ]]; then
		if [[ $force -eq 0 ]]; then
			yesno "Do you want to backup files first?"
			if [[ "$answer" == 'yes' ]]; then
				wx_backup || fail "Backup failed."
			fi
		else
			# only backup if necessary
			print "Will backup wx and active files if necessary"
			wx_backup -t || fail "Backup failed."
		fi
		backup_done=1;
		cd $workspace/$dir
	fi

	if [[ ! -f $file ]]; then
		fail "$filepath isn't a file."
	fi

	# this is used a couple times so save escape_re value
	efp=$(escape_re $filepath)

	if wx_pnt_filepath; then
		# Not a new file (has a parent)
		if is_active $filepath; then
			ring_bell
			cat >&2 <<-EOF

Warning! $filepath 
is in active list. You should run
"$ME reedit $filepath" 
"$ME unedit $filepath" 
which should remove it from the active list then run 
"$ME $command $filepath".
Note, if you have made changes to this file that you want to keep, back
it up first.

$filepath not deleted.

			EOF
			return 1
		fi
		# See if this is already in the renamed list
		if grep -q "^deleted_files/$efp " $wxdir/renamed; then
			ring_bell
			if [[ -f $workspace/deleted_files/$filepath ]]; then
				cat >&2  <<-EOF
Warning: $filepath
has already been deleted.
Check for deleted_files/$filepath
in $wxdir/renamed .
				EOF
			else
				cat >&2 <<-EOF
Warning! the $ME renamed list appears to be corrupt.
				EOF
				fail "Please run '$ME update -r' and try this"\
					"command again."
			fi
		fi
		if workspace filerm $file; then
			# we know filerm renames files under deleted_files/
			update_renamed_file $filepath deleted_files/$filepath

			print "$filepath deleted"
			print
			print "To recover $filepath do:"
			print "'cd $workspace'"
			print "'$ME mv deleted_files/$filepath $filepath'"
		else
			print "There was an error while trying to delete $filepath"
		fi
	else
		# This is a new file so let's remove it.
		if is_active $filepath; then
			ring_bell
			cat >&2 <<-EOF

Warning: $filepath 
is in active list. You should run
"$ME uncreate $filepath" 
which should remove it from the active list
then run "$ME $command $filepath". 

$filepath not deleted.

			EOF
			return 1
		fi

		answer='no'
		if [[ $force -ne 1 ]]; then
			cat <<-EOF

Warning: $filepath 
appears to be a new file.

Do you want to completely remove the file and SCCS info from 
your workspace?  (If you answer no, the file will just be 
removed from the active list if it's in there.  If you answer 
yes, the file and associated SCCS history files will removed 
from the active list and also removed entirely from the 
workspace.)

			EOF
			# yesno sets answer
			yesno "Completely remove $filepath?"
		else
			# forced to yes
			answer='yes'
		fi

		if [[ "$answer" == 'yes' ]]; then
			rm -f $file SCCS/s.$file
			[[ -f SCCS/p.$file ]] && rm -f SCCS/p.$file
			echo "$filepath removed from workspace."
			# For later cleanup, optional
			if grep -q "^$efp " $wsdata/nametable 2>/dev/null; then
				NEED_WS_CLEAN='y'
			fi
		fi
		remove_new $filepath
	fi
}

wx_mv() {
	# create some local variables to avoid side effects
	typeset efp old_filepath new_filepath

	cd $workspace

	old_filepath=$1
	new_filepath=$2

	if [[ -d $old_filepath && ( -d $new_filepath || ! -f $new_filepath ) ]]
	then

		if [[ $(basename $old_filepath) == "SCCS" ]]; then
			return
		fi

		echo "Doing a $command between two directories can take a "\
		    "while, please be patient."
		# deal with directory to directory move
		if [[ -d $new_filepath ]]; then
			base="$(basename $old_filepath)/"
		else
			base=
		fi

		sccsmv $old_filepath $new_filepath ||
		    fail "sccsmv $old_filepath $new_filepath failed."

		# remove previous renamed entry
		remove_renamed_entry $old_filepath

		update_renamed_dir $new_filepath/$base

		if grep -q "^$efp/" $wsdata/nametable 2>/dev/null; then
			# Old entries in workspace nametable so set this
			# to clean up on exit
			NEED_WS_CLEAN='y'
		fi

		# rename path of active entry
		sed "s|^$efp/|$new_filepath/$base|" $wxdir/active \
			   > $wxtmp/active || fail "Error: cannot create $wxtmp/active."
		mv $wxtmp/active $wxdir/active ||
			fail "Error: cannot create $wxdir/active."
		sed "s|^$efp/|$new_filepath/$base|" $wxdir/new \
			   > $wxtmp/new || fail "Error: cannot create $wxtmp/new."
		mv $wxtmp/new $wxdir/new || fail "Error: cannot create $wxdir/new."

	elif [[ -f $old_filepath && -d $new_filepath ]]; then
		wx_mv_file $old_filepath $new_filepath/$(basename $old_filepath)
	elif [[ -f $old_filepath && ! -f $new_filepath ]]; then
		wx_mv_file $old_filepath $new_filepath
	elif [[ ! -f $old_filepath ]]; then
		fail "Error! $old_filepath not found."
	elif [[ -f $new_filepath ]]; then
		fail "Error! $new_filepath exists."
	fi
}

wx_mv_file() {
	# store literal filepath in local var. to avoid side effects
	typeset efp old_filepath new_filepath

	cd $workspace

	old_filepath=$1
	new_filepath=$2

	if [[ ! -f $old_filepath ]]; then
		fail "Error! $old_filepath does not exist."

	elif [[ -f $new_filepath ]]; then
		fail "Error! $new_filepath already exists."

	else
		if cyclic_rename $new_filepath $old_filepath; then
			fail "Cyclic renamed detected. See 'man workspace'"\
				"for more info."
		fi

		if workspace filemv $old_filepath $new_filepath; then
			update_renamed_file $old_filepath $new_filepath
			efp=$(escape_re $old_filepath)
			if is_active $old_filepath; then
				# In active list so update list with new
				# file name
				rename_active_entry $old_filepath $new_filepath
			fi
			if grep -q "^$efp$" $wxdir/new; then
				remove_new $old_filepath
				add_new $new_filepath
			fi
			if grep -q "^$efp " $wsdata/nametable 2>/dev/null; then
				NEED_WS_CLEAN=y
			fi
		else
			echo "There was an error renaming $old_filepath to "\
			    "$new_filepath"
		fi
	fi
}

sccs_rmdel_done() {
	# Note there are literal tabs in the []'s below so be careful when
	# editing.

	# file not in SCCS so return false (1)
	[[ ! -f SCCS/s.$file ]] && return 1

	if wx_pnt_filepath; then
		sccs prt -a $parentfilepath > $wxtmp/parenthist
		sccs prt -a $file > $wxtmp/filehist
		diff $wxtmp/parenthist $wxtmp/filehist |
			grep '^> R [0-9]\.[0-9]'|
			egrep -v ' (Codemgr|Fake)[ 	]' |
			sed 's/^> //' > $wxtmp/newrmdels
		[[ ! -f $wxtmp/newrmdels ]] && fail "Error: cannot create $wxtmp/newrmdels"
		rm -f $wxtmp/parenthist $wxtmp/filehist
	else
		# New file, no parent
		sccs prt -a $file |
		    egrep -v \
			'^R [0-9]+(\.[0-9]+)+[ 	].* (Codemgr|Fake)[ 	]' |
		    egrep '^R [0-9]+(\.[0-9]+)+[ 	]' > $wxtmp/newrmdels
		[[ ! -f $wxtmp/newrmdels ]] && fail "Error: cannot create $wxtmp/newrmdels"
	fi

	if [[ -s $wxtmp/newrmdels ]]; then
		cat $wxtmp/newrmdels
		rm -f $wxtmp/newrmdels
		# an rmdel was done so return true
		return 0
	else
		rm -f $wxtmp/newrmdels
		# no rmdel was done so return false
		return 1
	fi
}

rmdelchk() {
	# returns 0 (success) if an rmdel was done.
	# Should be called via wx_eval().
	if sccs_rmdel_done ; then
		ring_bell
		cat <<-EOF

Warning, it looks like 'sccs rmdel' was run on $filepath
This will cause a problem for Teamware.  Please fix this.
Note, this can be fixed by doing '$ME reedit $filepath'
		EOF
		return 0
	else
		return 1
	fi
}

wx_delget() {
	typeset -i force=0
	typeset arg comment_found=false

	while getopts :f arg; do
		case $arg in
			 f) force=1;;
			 *) fail "Invalid flag -$OPTARG. See 'wx help' for"\
			 	"more info.";;
		esac
	done

	if [[ (! -f SCCS/s.$file && ! -f SCCS/p.$file) ||
		(-f SCCS/s.$file &&  -f SCCS/p.$file) ]]; then

		# Check for keywords unless force is set or file is in
		# keywords.NOT
		if [[ $force -ne 1 ]] && [ -f SCCS/p.$file ] &&
			! grep -q "^$(escape_re $filepath)$" \
				$wxdir/keywords.NOT 2>/dev/null &&
			! keywords -p $file; then

			ring_bell
			cat <<-EOF

The keywords check has detected a problem with $filepath
If this check should be skipped for this file, put the filepath in
${wxdir}/keywords.NOT.
See /net/wizard.eng/export/misc/general_docs/keyword_info.txt
for more info about keywords.  Note, pay attention to the tabs.

			EOF
			yesno "Continue with $command for $filepath?"
			if [[ "$answer" != 'yes' ]]; then
				echo "Aborting $command $filepath\n"
				return
			fi
		fi

		[[ -f $wxtmp/comment ]] && rm $wxtmp/comment
		if [[ -n "$comment_file" ]]; then
			# note hard tab in sed r.e.
			sed '/^[ 	]*$/d' $comment_file > $wxtmp/comment &&
			    comment_found=true
		else
			wx_show_comment >$wxtmp/comment && comment_found=true
		fi
		if $comment_found; then
			echo $filepath
			cat $wxtmp/comment
			if [[ -f SCCS/s.$file ]]; then
				# file history so check in file
				sccs delget $silent -y"`cat $wxtmp/comment`" \
					$file ||
					fail "sccs delget failed $filepath."
			else
				# no file history so create file
				sccs create $silent -y"`cat $wxtmp/comment`" \
					$file ||
					fail "sccs create $filepath failed."
				rm -f ,$file
			fi
			[[ -n "$comment_file" ]] &&
			    update_active_comment $filepath
		else
			ring_bell
			print "\nError: no comments (NO_COMMENT) registered for $filepath"
			if [[ $force -ne 1 ]] ; then
				yesno "Invoke ${EDITOR:-vi} to edit"\
					"$wxdir/active"'?'
				if [ "$answer" == 'yes' ]; then
					${EDITOR:-vi} $wxdir/active
					wx_delget
				else
					fail "Edit $wxdir/active and try again."
				fi
			else
				fail "Edit $wxdir/active and try again."
			fi
		fi
	elif [[ -f SCCS/s.$file && ! -f SCCS/p.$file ]]; then
		echo "$filepath already checked in"
	elif [[ ! -f SCCS/s.$file && -f SCCS/p.$file ]]; then
		fail "Error, $filepath is missing SCCS/s.$file ."
	fi
}

wx_get() {
	if [[ -f SCCS/s.$file ]]; then
		sccs get $args -s $file || fail "sccs get $file failed."
	else
		ring_bell
		echo "$filepath not in SCCS"
	fi
}

wx_info() {
	if [ -f SCCS/p.$file ]; then
		if [[ -w $file ]]; then
			echo "$filepath (checked out)"
		else
			ring_bell
			echo "$filepath (Warning, inconsistent state."
			echo "   SCCS/p.$file exists but $file is readonly.)"
		fi
	elif [[ ! -f $file ]]; then
		ring_bell
		echo "$filepath (Warning, not found in $workspace)"
	elif [[ ! -f SCCS/s.$file ]]; then
		ring_bell
		echo "$filepath (Warning, not in SCCS)"
	else
		echo "$filepath (checked in)"
	fi
	echo "Check-in comment:"
	wx_show_comment
	if [ -f SCCS/s.$file ]; then
		echo "Most recent delta: \c"
		sccs prt -y $file
	fi
	echo "File name status:"
	if renamed; then
		# old is set by renamed
		echo "Locally renamed, parent file = $parentfile"
	elif lookup_parent $filepath; then
		# parentfile is set by lookup_parent
		if [[ "$filepath" != "$parentfile" ]]; then
			echo "In parent ws, file renamed to: $parentfile"
		else
			echo "Same as parent."
		fi
	else
		echo "New file (does not exist in parent ws)."
	fi
	echo
}

get_multi_deltas() {
	# Get list of files with more that one delta when putback.
	# set global multi_delta_list.
	if ! deltachk >/dev/null 2>&1; then
		multi_delta_list="$multi_delta_list $filepath"
	fi
}

wx_reedit() {
	typeset -i numkids=`workspace children | wc -l`
	typeset i newfiles only_multideltas=false

	case $1 in
		-m)	only_multideltas=true;;
		-*)	fail "Invalid flag $1. See 'wx help' for more"\
		  		"info.";;
	esac

	if [[ ! -f $wsdata/nametable ]]; then
		echo "$wsdata/nametable not found, all files assumed new."
		ok_to_proceed "Okay to continue with $command?"
	elif [[ ! -r $wsdata/nametable ]]; then
		fail "Error: cannot read $wsdata/nametable."
	fi

	if $only_multideltas; then
		# get_multi_deltas sets multi_delta_list
		wx_eval get_multi_deltas
		# set file_list for wx_eval wx_reedit_file below
		file_list=$multi_delta_list
	fi

	cd $workspace

	for i in $file_list; do
		if [[ ! -f $i ]]; then
			fail "$i does not exist."
		fi
		if ! lookup_parent $i; then
			if [[ -z $newfiles ]]; then
				newfiles="$i"
			else
				newfiles="$newfiles\n$i"
			fi
		fi
	done

	if [[ -n $newfiles ]]; then
		# If there are some new files, give user a warning
		cat <<-EOF | ${PAGER:-more}

$ME thinks following files are new (not in parent workspace) and will
reset their file histories to version 1.1 (exit if this list isn't correct):
$(echo $newfiles)

		EOF
		ok_to_proceed "Okay to continue with $command?"
		if ! $CHECKIN; then
			cat <<-EOF

Hint, use '$ME redelget' to collapse/reset new file histories to version
1.1 since '$ME $command' will check out the file and '$ME delget' always
increments the file version doing the check in.

			EOF
		fi
	fi

	if [ $numkids -gt 0 ]; then
		echo "WARNING: This workspace has the following children:"
		echo
		workspace children
		echo
		echo "The reedit command will coalesce all children's deltas"
		echo "into one, losing all delta comments in the process."
		ok_to_proceed 'Are you sure you want to proceed?'
	fi
	echo
	yesno "Do you want to backup files first?"
	if [[ "$answer" == 'yes' ]]; then
		wx_backup || fail "Backup failed."
	fi

	echo "$command beginning..."
	echo
	wx_eval wx_reedit_file
	echo
	echo "$command complete"
	echo
	[[ $ACTSORT == sort ]] && do_active_sort=true
}

wx_reedit_file() {
	# Must be called via wx_eval
	typeset comment_found=false

	if [[ ! -f $file ]]; then
		echo "$file does not exist.  Can not reedit $file"
		return
	fi

	echo $filepath
	# Is there a parent file?
	if wx_pnt_filepath; then
		rm -f $wxtmp/s.$file
		cp -p $parentsdot $wxtmp/s.$file ||
			fail "Error: cannot cp $parentsdot $wxtmp/s.$file ."

		# get the latest parent delta and comment and filter out
		# certain fields removing trailing spaces

		p_delta="$(sccs prt -y $parentsdot|expand -1|grep 'SCCS'|\
				   cut -f'4,5,6,9-' -d' '|sed 's/  *$//')"

		if [[ -z "$p_delta" ]]; then
			ring_bell
			echo "Warning ${command}: skipping $filepath,"
			echo "cannot get parent delta info"
			echo
			return 1
		fi

		# create a list of local deltas in the same format
		# also removing trailing spaces
		sccs prt $file|expand -1|
			nawk '
			/^D [0-9]+(\.[0-9]+)+ +[0-9][0-9]\/[0-9][0-9]/ {
				if (delta != "") {
					# print previous delta info
					print delta comment;
				}
				delta=sprintf("%s %s %s %s ",$3, $4, $5, $8);
				comment = "";
			}
			! /^D [0-9]+(\.[0-9]+)+ +[0-9][0-9]\/[0-9][0-9]/ {
				# Add comment lines to comment variable
				if (comment == "") {
					if (NF > 0) {
						comment = $0;
					} else {
						# empty lines require a space
						# in comment.
						comment = " ";
					}
				} else {
					if (NF > 0) {
						comment = comment " " $0;
					} else {
						comment = comment " ";
					}
				}
			}
			END {
				if (delta != "") {
					# print last delta info
					print delta comment;
				}
			}' | sed 's/  *$//' > $wxtmp/l_deltas ||
			    	fail "Error: cannot create $wxtmp/l_deltas."

		# If the latest parent delta doesn't appear in the local file
		# then a bringover is required.  Use fgrep because comment may
		# have RE chars in it.
		if ! fgrep "$p_delta" $wxtmp/l_deltas >/dev/null; then
			ring_bell
			echo "\nWarning ${command}: skipping $filepath because:"
			echo "parent's version of $filepath"
			echo "is newer than child's -- bringover required."
			echo
			return 1
		fi

		if [ ! -f SCCS/p.$file ]; then
			if sccs edit $silent $file; then
				update_active $filepath
			else
				fail "sccs edit $file failed."
			fi
		fi

		# make copy of local file and copy parent's SCCS s. file over
		# local.
		mv -f $file ${file}.wx_reedit ||
			fail "mv -f $file ${file}.wx_reedit failed."
		rm -f SCCS/s.$file SCCS/p.$file
		cp $wxtmp/s.$file SCCS/s.$file ||
			fail "cp $wxtmp/s.$file SCCS/s.$file failed."

		if sccs edit $silent $file; then
			update_active $filepath
		else
			fail "sccs edit $file failed."
		fi

		mv -f ${file}.wx_reedit $file ||
			fail "mv -f ${file}.wx_reedit $file failed."

		if $CHECKIN; then
			wx_delget
		fi
		touch $file
	else
		# reediting a new file.
		if [[ -f SCCS/s.$file ]]; then
			if [[ ! -f SCCS/p.$file ]]; then
				# File needs to be checked out
				sccs edit $silent $file ||
				    fail "sccs edit $file failed."
			fi
			# clean up SCCS since we are going to create again.
			rm -f SCCS/s.$file
		fi
		# clean up SCCS since we are going to create again.
		[[ -f SCCS/p.$file ]] && rm -f SCCS/p.$file

		[[ -f $wxtmp/comment ]] && rm $wxtmp/comment
		wx_show_comment >$wxtmp/comment && comment_found=true
		if $comment_found; then
			echo $filepath
			cat $wxtmp/comment
			rm -f SCCS/s.$file SCCS/p.$file
			sccs create $silent -y"`cat $wxtmp/comment`" $file ||
			    fail "sccs create $filepath failed."
			rm -f ,$file
			[[ -n "$comment_file" ]] &&
			    update_active_comment $filepath
		else
			ring_bell
			echo "\nError, no comments registered for $filepath"
			if [[ $force -ne 1 ]] ; then
				yesno "Invoke ${EDITOR:-vi} to edit"\
					"$wxdir/active"'?'
				if [[ "$answer" == 'yes' ]]; then
					${EDITOR:-vi} $wxdir/active
					wx_reedit_file
				else
					fail "Edit $wxdir/active and try again."
				fi
			else
				fail "Edit $wxdir/active and try again."
			fi
		fi

		if $CHECKIN; then
			# No need to check out file.
			return
		fi

		if sccs edit $silent $file; then
			update_active $filepath
			add_new $filepath
		else
			fail "sccs edit $file failed."
		fi
	fi
}

#
# Warn if there are sccs delta issues
#
deltachk() {
	# must be run via wx_eval
	typeset -i numdeltas
	typeset newfile checkedout=false

	if wx_pnt_filepath; then
		# find number of deltas by subtracting the number in the parent
		# from the local file (note the literal Control-A in the grep
		# R.E.s below).
		(( numdeltas = $(grep '^
d D' SCCS/s.$file|wc -l) - \
				    $(grep '^
d D' $parentsdot|wc -l) ))
		newfile=false
	else
		# checking a new file (note the literal Control-A in the grep
		# R.E.)
		numdeltas=$(grep '^
d D' SCCS/s.$file|wc -l)
		newfile=true
	fi

	if [[ -z $numdeltas ]]; then
		cat <<-EOF

Warning: the local file:
$filepath
does not appear to have a sccs delta history file or the sccs delta
history file is corrupt.  If the local file is new try using:
"cd $dir"
"$ME create $file"

If the file is not new (exists in parent):
"cd $dir"
Save a copy of the local file
Remove the SCCS/[ps].$file history files
"bringover $filepath"
"$ME edit $file"
Then carefuly merge the saved copy of local file with the
file brought over from parent.  Hint: twmerge is a good merge 
tool.
		EOF
		return 1
	fi

	[[ -f SCCS/p.$file ]] && checkedout=true

	# Note the use of hard tabs in the messages
	case $numdeltas in
		0)	if $checkedout; then
                                # file is checked out so assume there
                                # will be 1 delta when checked in.
				return 0
			else
				if [[ -n $parentfilepath ]];  then
					if cmp -s $file $parentfilepath; then
						cat <<-EOF

Warning: the local file:
$filepath
and the parent file:
$parentfilepath
content are identical.  There are no new deltas in the local file.
If this file is no longer required in the active list use:
"cd $dir"
"$ME reset $file"
to remove file from the wx state files (active list, etc...)
						EOF
					else
						cat <<-EOF

Warning: the local file:
$filepath
and the parent file:
$parentfilepath
have the same number of deltas but contents differ.  A bringover may be
required before putback.
						EOF
					fi
				else
					cat <<-EOF

Warning: the local file:
$filepath
is new but doesn't appear to contain any deltas.  The SCCS delta history file
may need to be recreated.  If so: 
"cd $dir"
"rm SCCS/s.$file"
"$ME create $file"
					EOF
				fi
				return 1
			fi ;;

		1)	if $checkedout; then
				cat <<-EOF

Regarding $filepath
Warning! There may be more than 1 delta when you check this file in
(currently checked out).  Run '$ME redelget' on this file to collapse
the deltas and check in with 1 delta unless putting back > 1 bug.
				EOF
				return 1
			else
				return 0
			fi ;;

		-*) # a negative number means the parent has more deltas

			cat <<-EOF

Regarding $filepath
Warning! The parent file has more deltas than the local file.
You should bringover the local file to fix this.
			EOF
			;;

		*)	if $newfile && $checkedout; then
				cat <<-EOF

Regarding $filepath
Warning! There may be more than 1 delta when you check this file in
(currently checked out).  Run '$ME redelget' on this file to collapse
the deltas and check in with 1 delta unless putting back > 1 bug.
				EOF
			else
				cat <<-EOF

Regarding $filepath
Warning! There is more than 1 delta.  Run:
'cd $dir; $ME redelget $file' 
to collapse the deltas on this file and check in with 1 delta unless
putting back > 1 bug.
				EOF
			fi
			return 1;;
	esac
}

wx_cstyle() {
	case $file in
		*.[ch])	;;
		*)	return;;
	esac
	((CSTYLE_INDEX = CSTYLE_INDEX + 1))
	(cd $workspace;
	 cstyle ${CSTYLE_FLAGS} $args $filepath >\
	    $wxtmp/wx.cstyle.$CSTYLE_INDEX) &
}

wx_jstyle() {
	case $file in
		*.java)	;;
		*)	return;;
	esac
	((JSTYLE_INDEX = JSTYLE_INDEX + 1))
	(cd $workspace;
	 jstyle ${JSTYLE_FLAGS} $args $filepath >\
	    $wxtmp/wx.jstyle.$JSTYLE_INDEX) &
}

wx_find_compression_progs() {
	gzip=/usr/bin/gzip
	if [[ ! -x $gzip && -n "$GZIPBIN" ]]; then
		gzip=$GZIPBIN
	fi

	bzip2=/usr/bin/bzip2
	if [[ ! -x $bzip2 && -n "$BZIP2BIN" ]]; then
		bzip2=$BZIP2BIN
	fi
}

wx_get_backup_dir() {
	typeset backup_dir_file
	# if backup_dir hasn't been set already...
	if [[ -z "$backup_dir" ]]; then
		# use the backup dir specifier in the wx/
		backup_dir_file=$wxdir/backup_dir
		if [[ ! ( -f $backup_dir_file && -r $backup_dir_file &&
			-s $backup_dir_file ) ]]; then
			fail "$backup_dir_file: missing, empty, or not readable"
		fi
		backup_dir=`cat $backup_dir_file`
	fi
	if [[ ! ( -d $backup_dir && -x $backup_dir && -r $backup_dir ) ]]; then
		fail "$backup_dir: missing, not a directory, or bad permissions"
	fi
}

#
# This code requires that the files (n.sdot, n.pdot and n.clear) for a given
# backup have the same extension (.tar, .tar.gz, or .tar.bz2).  It also
# disallows the existance of two incarnations of the same file (i.e.
# n.clear.tar and n.clear.tar.gz)
#
# It's up to the user to straighten things out if the above conditions are
# violated.  The only time that is a problem is if they are trying to
# restore a version which violates the above rules.
#
#  Takes one argument, the version number.
#
#  Returns:
#	(return code)	0 if exists and consistent,
#			1 if not found,
#			2 if inconsistent
#	b_clear, b_sdot, b_pdot	On success, the full path to the clear, sdot
#	and pdot files comp, ext	The compression program for and
#	extension of said files
#
wx_check_backup() {
	typeset _new _b_new _renamed _b_renamed _active _b_active \
		_local_nt _b_local_nt found bad

	_version=$1
	clear=$_version.clear.tar
	sdot=$_version.sdot.tar
	pdot=$_version.pdot.tar
	not=$_version.not.tar
	_renamed=$_version.renamed
	_b_renamed=$backup_dir/$_renamed
	_new=$_version.new
	_b_new=$backup_dir/$_new
	_active=$_version.active
	_b_active=$backup_dir/$_active
	_local_nt=$_version.local_nametable
	_b_local_nt=$backup_dir/$_local_nt
	_sort=$_version.sort_active
	_b_sort=$backup_dir/$_sort
	found=false
	bad=false
	#
	# these arrays must be in sync with:
	# 1. the immediately following _count variable
	# 2. wx_find_last_backup's egrep expression
	# 3. wx_backup's "$args" handling.
	# 4. wx_find_compression_progs's programs
	#
	set -A _comps	""  "$gzip" "$bzip2"
	set -A _extns	""  ".gz"   ".bz2"
	_count=3

	idx=0
	while [[ $idx -lt $_count ]] ; do
		_ext=${_extns[$idx]}
		_comp=${_comps[$idx]}
		_clear=$clear$_ext
		_sdot=$sdot$_ext
		_pdot=$pdot$_ext
		_b_clear=$backup_dir/$_clear
		_b_sdot=$backup_dir/$_sdot
		_b_pdot=$backup_dir/$_pdot

		if [[ -f $_b_clear || -f $_b_sdot ]]; then
			if $found; then
				echo "$backup_dir: both $_version.*.tar$ext "\
					 "and $_version.*.tar$_ext exist"
				bad=true
			else
				ext=$_ext
				comp=$_comp
				found=true
			fi
		fi

		if [[ -f $_b_clear && ! -f $_b_sdot ]]; then
			echo "$backup_dir: $_clear exists; $_sdot does not"
			bad=true
		elif [[ ! -f $_b_clear && -f $_b_sdot ]]; then
			echo "$backup_dir: $_sdot exists; $_clear does not"
			bad=true
		elif [[ ! -f $_b_sdot && -f $_b_pdot ]]; then
			echo "$backup_dir: $_pdot exists; $_sdot does not"
			bad=true
		fi
		idx=`expr $idx + 1`
	done

	if [[ ! -f $_b_renamed && -f $_b_active ]]; then
		# Can determine compression only
		return 1
	fi

	if [[ -f $_b_renamed && -f $_b_active && -f $_b_new &&
		-f $_b_local_nt ]]; then
		found=true
	else
		bad=true
	fi

	$bad && return 2
	$found || return 1

	b_renamed=$_b_renamed
	b_new=$_b_new
	b_active=$_b_active
	b_local_nt=$_b_local_nt

	if [[ -f $backup_dir/$clear$ext && -f $backup_dir/$sdot$ext ]]; then
		b_clear=$backup_dir/$clear$ext
		b_sdot=$backup_dir/$sdot$ext
	else
		b_clear=
		b_sdot=
	fi

	# It's not an error if this doesn't exist.
	if [[ -f $backup_dir/$pdot$ext ]]; then
		b_pdot=$backup_dir/$pdot$ext
	else
		b_pdot=
	fi
	# It's not an error if this doesn't exist.
	if [[ -f $backup_dir/$not ]]; then
		b_not_files=$backup_dir/$not
	else
		b_not_files=
	fi
	# It's not an error if this doesn't exist.
	if [[ -f $_b_sort ]]; then
		b_sort=$_b_sort
	else
		b_sort=
	fi

	return 0
}

#
# finds the number of the last backup.
#
# Returned in $result, which is -1 if no backups are found
#
wx_find_last_backup() {
	#
	# The list of extensions in the egrep expression must be in sync
	# with wx_check_backup's arrays
	#
	result=`ls -1 $backup_dir | egrep \
	    '^[0-9][0-9]*\.((pdot|sdot|clear)\.tar($|\.gz$|\.bz2$)|active|renamed|new|local_nametable$)'| \
	    sed 's/^\([0-9][0-9]*\)\..*$/\1/'| sort -rn | head -1`

	[[ -n "$result" ]] # fail if result is empty
}

#
# wx_do_backup
# Returns 0 on successful backup, 1 if nothing to backup, 2 any other
# error.
#

wx_do_backup() {
	_type=$1	# type of files (for user)
	_out=$2		# file to write to
	_comp="$3"	# compression program, or empty for no compression
	_evalarg=$4	# arg to wx_eval to get the correct file list
	typeset backupfiles=$(wx_eval "$_evalarg")

	echo
	echo "Saving $_type files to $_out"
	echo

	if [[ -z $backupfiles ]]; then
		echo "Note, nothing to backup."
		return 1
	fi

	if [[ -n "$_comp" ]]; then
		( tar cvf - $backupfiles 2>$BACKUP_ERRORS || \
		    rm -f $_out ) | $_comp -9 -c > $_out || rm -f $_out
	else
		tar cvf $_out $backupfiles 2>$BACKUP_ERRORS ||
		    rm -f $_out
	fi

	[[ -f "$_out" ]] || return 2	# $_out is removed on any error

	return 0
}

wx_do_restore() {
	_type=$1		# type of files (for user)
	_in=$2		  # file to read from
	_comp="$3"	  # uncompressing program
	echo
	echo "Restoring $_type files from $_in"
	echo

	if [[ -n "$_comp" ]]; then
		#
		# if decompression fails, echo a bad value to make tar fail
		#
		($_comp -dc < $_in || echo "fail") | tar xvpf - || return 1
	else
		tar xvpf $_in || return 1
	fi
	return 0
}

#
# do renames in a workspace from a backup set
#

wx_do_renames() {
	typeset _in=$1 # file to read from

	if [[ ! -f $wsdata/nametable ]]; then
		echo "$wsdata/nametable not found, not doing renames."
		return 0
	fi

	echo
	echo "Restoring renamed files from $_in"
	echo

	# Note this assumes we're staring in $workspace

	while read new hash1 hash2 hash3 hash4; do
		# get current local file name
		current=$(grep " $hash1 $hash2 $hash3 $hash4$" \
				$wsdata/nametable | cut -f1 -d' ')

		if [[ -z $current ]]; then
			# nothing to rename
			continue
		fi

		if [[ "$new" == "$current" ]]; then
			# rename not needed
			continue
		fi

		if [[ ! -f $new ]]; then
			if [[ ! -d $(dirname $new) ]]; then
				mkdir -p $(dirname $new) ||
					fail "Error: cannot create dir $(dirname $new)"
			fi
			echo "Renaming current workspace file $current to $new"
			workspace filemv $current $new
		else
			if [[ -f $current ]]; then
				ring_bell
				cat >&2 <<-EOF

Warning: $current 
and $new 
files both exist in current workspace with the
same hash.  The restored renamed list should be recreated by running:
'$ME update -r'
Skipping rename of $current 
to $new
				EOF

			fi
		fi
	done < $_in

	return 0
}

wx_backup() {
	typeset orig_file_list ws_file back_file
	typeset newer=false
	typeset origdir=$PWD

	case $1 in
		-i)	wx_get_backup_dir
			echo "Backup dir is $backup_dir"
			ls -ltr $backup_dir
			echo "Backup dir is $backup_dir"
			cd $origdir
			return ;;
		-t) 	newer=true
                        # backup if wx files are newer than last backup.
                        # Implies use of default compression and no
                        # interaction.  Doing shift so case further down
                        # won't see -t.
			shift;;
	esac
	# save state in case wx_backup called from another command.
	orig_file_list=$file_list

	# we always backup the active files.
	file_list=$(wx_active)

	if [[ ! -s $wxdir/renamed && -z $file_list ]]; then
		echo "There isn't anything to backup."
                file_list=$orig_file_list
		return 0
	fi

	# must be in workspace to do backup
	cd $workspace || fail "Error: cannot cd $workspace"

	if $newer; then
		# get latest wx state files and active files but skip
		# wx/tmp and wx/*.old files.
		ws_file=$(ls -1t $wxdir/!(tmp|*.old) $file_list|head -1)
		# get latest backup.
		wx_get_backup_dir
		back_file=$(ls -1t $backup_dir/*|head -1)
		if [[ ( -z "$back_file" && -n "$ws_file" ) || \
			(( -n "$back_file" && -n "$ws_file" ) && \
			$ws_file -nt $back_file ) ]]
		then
			: # continue with backup
		else
			print "Skipping backup, last backup newer than wx"\
				"files."
                        file_list=$orig_file_list
			cd $origdir
			return 0
		fi
	fi

	wx_find_compression_progs
	wx_get_backup_dir

	if [[ ! -w $backup_dir ]]; then
		fail "$backup_dir: not writable"
	fi

	if wx_find_last_backup; then
		prev_backup=$result
		version=`expr $result + 1`
	else
		prev_backup=
		version=0
	fi

	#
	# This must be in sync with wx_check_backup's arrays
	#
	case $1 in
		-n) ext=;	comp=;;
		-z) ext=.gz;	comp=$gzip;;
		-b) ext=.bz2; comp=$bzip2;;
		"-") shift;; # treat this as use default compression
		"") ;; # treat this as use default compression
		-??*) fail "$ME $command: only accepts a single argument";;
		*)  fail "$ME $command: unrecognized argument";;
	esac

	if [[ -z "$1" ]]; then
		#
		# default to the compression of the previous backup
		#
		if [[ -z "$prev_backup" ]]; then
			ext=
			comp=
		else
			wx_check_backup $prev_backup
			# A return of 1 is okay
			if [ $? -gt 1 ]; then
				echo "$backup_dir/$prev_backup.*: "\
					"cannot determine previous "\
					"compression."
				if $newer; then
                                        # Assume we want backup.
					answer="yes"
				else
					yesno "Proceed with no "\
						"compression?"
				fi
				if [[ $answer == "no" ]]; then
					echo "No backup done."
                                        file_list=$orig_file_list
					cd $origdir
					return
				fi
				ext=
				comp=
			fi
		fi
	fi

	if [[ -n "$comp" && ! -x "$comp" ]]; then
		echo "${comp}: missing.  defaulting to no compression"
		ext=
		comp=
	fi

	b_clear=$backup_dir/$version.clear.tar$ext
	b_sdot=$backup_dir/$version.sdot.tar$ext
	b_pdot=$backup_dir/$version.pdot.tar$ext
	b_local_nt=$backup_dir/$version.local_nametable
	b_active=$backup_dir/$version.active
	b_renamed=$backup_dir/$version.renamed
	b_new=$backup_dir/$version.new
	b_not_files=$backup_dir/$version.not.tar
	b_sort=$backup_dir/$version.sort_active

	#
	# If anything goes wrong, clean up after ourselves
	#
	trap "/usr/bin/rm -f $b_clear $b_sdot $b_pdot $b_active $b_renamed $b_new $b_local_nt $b_not_files $b_sort; exit 1" 0 1 2 3 15

	fail_msg='failed.  Cleaning up. '

	#
	# It is not a hard error for the SCCS/s.file to be missing.  We just
	# let the user know what's going on.
	#
	sdot_cmd='
_sdot="SCCS/s.$file";
_file="$dir/$_sdot";
if [[ -f $_sdot ]]; then
	echo "$_file";
else
	echo "$_file: not found" >&2;
fi
'
	pdot_cmd='
_pdot="SCCS/p.$file";
_sdot="SCCS/s.$file";
_file="$dir/$_pdot";
if [[ -f $_pdot ]]; then
	echo "$_file";
elif [[ ! -f $_sdot ]]; then
	echo "$_file: not checked in" >&2;
elif [[ -w $file ]]; then
	echo "$_file: not found but $file is writable!" >&2;
fi
'
	# Do this first in case there are no active files
	echo
	echo "Saving renamed file list to $b_renamed"
	echo
	cp $wxdir/renamed $b_renamed || fail "$b_renamed: $fail_msg"

	if [[ -f $wxdir/local_nametable ]]; then
		echo
		echo "Saving local_nametable to $b_local_nt"
		echo
		cp $wxdir/local_nametable $b_local_nt || \
			fail "$b_local_nt: $fail_msg"
	fi

	if [[ -f $wxdir/sort_active ]]; then
		print
		print "Saving sort_active to $b_active"
		print
		cp $wxdir/sort_active $b_sort || fail "$b_sort: $fail_msg"
	fi

	if ls wx/*.NOT >/dev/null 2>&1; then
		echo
		echo "Saving .NOT files to $b_not_files"
		echo
		tar -cf $b_not_files wx/*.NOT || fail "$b_not_files: $fail_msg"
	fi

	# Are there any active files to backup?
	if [[ -n $file_list ]]; then
		wx_do_backup 'clear' $b_clear "$comp" 'echo $filepath' ||
			fail "$b_clear: $fail_msg"

		wx_do_backup 'sdot' $b_sdot "$comp" "$sdot_cmd" ||
			fail "$b_sdot: $fail_msg"

		echo
		echo "Saving new list to $b_new"
		echo
		cp $wxdir/new $b_new || fail "$b_new: $fail_msg"

		# It's not fatal if the backup error for pdot files is
		# 'no files to backup'.  This is because it's possible
		# that the active files aren't checked out so there
		# won't be any pdot files.
		wx_do_backup 'pdot (if any)' $b_pdot "$comp" "$pdot_cmd"
		if [[ $? -gt 1 ]]; then
			fail "$b_pdot: $fail_msg $(cat $BACKUP_ERRORS)"
		fi
	fi

	echo
	echo "Saving active file list to $b_active"
	echo
	cp $wxdir/active $b_active || fail "$b_active: $fail_msg"

	trap - 0 1 2 3 15

	rm -f $BACKUP_ERRORS

	# restore file_list state.
	file_list=$orig_file_list

	cd $origdir
	return 0
}

wx_restore() {
	typeset force=0

	case $1 in
		-f) force=1;;
		-*) fail "Invalid flag $1. See 'wx help' for more  info.";;
	esac

	if [[ $force -eq 0 ]]; then
		cat <<-EOF

Warning, the restore command will overwrite several files including the
active and renamed lists.  This could be a problem if you have made
changes to your workspace and $ME related files following the last
backup.  It may be a good idea to run:

$ME update

after the restore so that the active and renamed lists are updated with
the new changes in the workspace.

Also, restore may perform workspace renames in this workspace if it
finds that the existing file has a pathname that differs from that in
the backup being restored.

		EOF
		ok_to_proceed "Do you really want to do the restore?"
	fi

	wx_find_compression_progs
	wx_get_backup_dir

	if wx_find_last_backup; then
		version=$result
	else
		fail "$backup_dir: no backups found"
	fi

	if [[ $force -eq 0 ]]; then
		ask 'Version to restore from' $version
		version=$answer
	fi

	#
	# wx_check_backup sets $comp, $b_clear, and $b_sdot when successful
	#
	if wx_check_backup $version; then
		:
	else
		if [[ $? -eq 2 ]]; then
			fail "$backup_dir/$version.*: unable to restore"\
				"inconsistent version"
		else
			fail "$backup_dir: Unable to find version $version"
		fi
	fi

	b_active=$backup_dir/$version.active

	if [[ -n "$comp" && ! -x "$comp" ]]; then
		fail "${comp}: missing -- cannot decompress $b_clear"
	fi

	# must be in workspace to do restore
	cd $workspace || fail "Error: cannot cd $workspace"

	[[ -f $b_renamed ]] || fail "$b_renamed: missing"
	[[ -f $b_new     ]] || fail "$b_new: missing"
	[[ -f $b_active  ]] || fail "$b_active: missing"

	[[ -r $b_renamed ]] || fail "$b_renamed: not readable"
	[[ -r $b_new     ]] || fail "$b_new: not readable"
	[[ -r $b_active  ]] || fail "$b_active: not readable"

	if [[ -f $b_clear ]]; then
		[[ -r $b_clear ]] || fail "$b_clear: not readable"
	fi
	if [[ -f $b_sdot ]]; then
		[[ -r $b_sdot ]] || fail "$b_sdot: not readable"
	fi
	if [[ -f $b_pdot ]]; then
		[[ -r $b_pdot ]] || fail "$b_pdot: not readable"
	fi
	if [[ -f $b_local_nt ]]; then
		[[ -r $b_local_nt ]] || fail "$b_local_nt: not readable"
	fi
	if [[ -f $b_not_files ]]; then
		[[ -r $b_not_files ]] || fail "$b_not_files: not readable"
	fi
	if [[ -f $b_sort ]]; then
		[[ -r $b_sort ]] || fail "$b_sort: not readable"
	fi

	#
	# If something goes wrong, we need to make sure they notice, so
	# we make the message quite visible, and echo a BELL.
	#
	fail_msg='Extraction failed.

	*DANGER* *DANGER* workspace could be corrupted *DANGER* *DANGER*'

	cp $b_renamed $wxdir/renamed || fail "$wxdir/renamed: $fail_msg"
	cp $b_new $wxdir/new || fail "$wxdir/new: $fail_msg"
	cp $b_active $wxdir/active || fail "$wxdir/active: $fail_msg"
	cp $b_local_nt $wxdir/local_nametable ||
		fail "$wxdir/local_nametable: $fail_msg"
	if [[ -n $b_sort ]]; then
		cp $b_sort $wxdir/sort_active || \
			fail "$wxdir/sort_active: $fail_msg"
	fi

	# Need to move active files that are renamed in current ws back to
	# their name in the active list to avoid two copies of the file
	# occuring when the clear files are restored below.
	wx_do_renames $wxdir/local_nametable ||
		fail "$wxdir/local_nametable: $fail_msg"

	if [[ -n $b_not_files ]]; then
		tar -xf $b_not_files || fail "$wx/*.NOT: $fail_msg"
	fi
	# It's not an error if there is no clear backup.
	if [[ -f $b_clear ]]; then
		wx_do_restore "clear" $b_clear "$comp" ||
		    fail "$b_clear: $fail_msg"
	fi
	# It's not an error if there is no sdot backup.
	if [[ -f $b_sdot ]]; then
		wx_do_restore "sdot" $b_sdot "$comp" ||
			fail "$b_sdot: $fail_msg"
	fi
	# It's not an error if there is no pdot backup.
	if [[ -f $b_pdot ]]; then
		wx_do_restore "pdot" $b_pdot "$comp" ||
			fail "$b_pdot: $fail_msg"
	fi

	# Do some integrity checking
	for filepath in $(wx_active); do
		if cd ${workspace}/$(dirname $filepath); then
			file=$(basename $filepath)

			# If file is not writable then assume the
			# SCCS/p.file is bogus.  This can happen if a
			# file is checked out and a wx restore is done
			# and the restored file was not checked out when
			# it was backed up.

			if [[ ! -w $file && -f SCCS/p.$file ]]; then
				ring_bell
				cat <<-EOF

Warning! $filepath is in inconsistent state.
$filepath is not writable and SCCS/p.$file exists.
Removing SCCS/p.$file 
To edit the file run '$ME edit $filepath'
				EOF
				rm -f SCCS/p.$file
			elif [[ -w $file && ! -f SCCS/p.$file ]]; then
				ring_bell
				cat <<-EOF

Warning! $filepath is in inconsistent state.
$filepath is writable 
but there is no SCCS/p.$file

				EOF
				yesno "Should this file be checked out?"
				if [[ "$answer" == 'yes' ]]; then
					if mv $file $wxtmp; then
						if sccs edit $file; then
							update_active $filepath
						fi
						mv -f $wxtmp/$file $file
					fi
				else
					ask_remove_active_entry
					echo "Setting $filepath read only"
					chmod ugo-w $file
				fi
			fi
		else
			ring_bell
			echo "\nWarning! Could not check sccs state of "\
			    "$filepath"
		fi
	done
}

wx_fullreview() {
	if wx_pnt_filepath; then
		:
	else
		parentfilepath=/dev/null
	fi
	if $show_comments && wx_show_comment > $wxdir/comment; then
		comm=-y"`cat $wxdir/comment`"
		codereview "$comm" $args $parentfilepath $workspace/$filepath
	else
		codereview $args $parentfilepath $workspace/$filepath
	fi
}

#
# Check on RTI status for bug ID's found in active list comments.
#

wx_rtichk() {
	# gate contains the gate dir, not full path
	typeset gate=${parent##*/}
	typeset -i rc=0
	typeset nolookup opt

	if [[ -f $wxdir/rtichk.NOT ]]; then
		print "\nSkipping RTI check:"
		return
	else
		print "\nDoing RTI check:"
	fi

	while getopts :N opt; do
		case $opt in
			N) nolookup='-N' ;;
			*) fail "Invalid flag -$OPTARG." ;;
		esac
	done

	# Note, rtichk needs a gate arg to correctly determine status.
	if [[ -z $gate ]]; then
		cat >&2 <<-EOF
Warning: cannot find a parent gate, skipping RTI checking.
		EOF
	fi

	# Use wx_summary to output bug ID's in active list comments,
	# redirecting warnings about non-bug ID's to file for later use.
	set -A bugs $(wx_summary -ao $nolookup 2>$wxtmp/bugwarnings|cut -f1 -d' ')
	rtichk -g $gate ${bugs[@]}
	rc=$?

	if [[ -s $wxtmp/bugwarnings ]]; then
		cat <<-EOF

There are issues with the bug ID format in the 
$wxdir/active file.
Please fix the following and run rtichk again:

		EOF
		cat $wxtmp/bugwarnings
		((rc = 1))
	fi
	if [[ ${#bugs} -eq 0 ]]; then
		print "\nWarning: no bug ID's in active list."
	fi
	return $rc
}

#
# Do a Teamware putback of active and renamed files.
#
wx_putback() {
	# Use pbargs array to store Teamware putback args.
	# verbatim is for -v verbatim flag which doesn't get passed to
	# putback.
	set -A pbargs
	typeset i verbatim pbfiles narg=false force=false
	typeset nolookup=false

	if $FILES_PASSED; then
		# use the user specified files
		pbfiles=$file_list
	else
		# use the pblist (active and renamed)
		pbfiles=$(wx_active -p)
	fi

	while getopts :fnp:qvN i; do
		case $i in
			# Force the putback (no user interaction)
			f)	force=true;;

			n)	narg=true
				pbargs[${#pbargs[@]}]="-$i" ;;

			q)	pbargs[${#pbargs[@]}]="-$i" ;;

			p)	pbargs[${#pbargs[@]}]="-$i"
				pbargs[${#pbargs[@]}]="$OPTARG"
				# setting parent for user prompt below
				parent="$OPTARG" ;;

				# -v doesn't get passed to putback.
			v)	verbatim='-v';;

			N)	nolookup='-N';;

		  	*)	fail "Invalid flag -$OPTARG. See 'wx help'"\
					"for more info.";;
		esac
	done

	if ! $narg; then
		# real putback

		# get pb comments, will be used later.
		if ! wx_summary -p $verbatim $nolookup >$wxtmp/pb_comments; then
			# Fail if comments have problems.
			fail "\nError, improper comments found. Use -v"\
				"to bypass this check."
		fi

		if ! $force; then
			# not force so give more warning.
			( # using subshell to capture stdout to file.
			cat <<-EOF
Remember to run '$ME pbchk' before doing a final putback (esp. if
doing a putback to an official ON gate).  Make sure your workspace 
parent ($parent) is correct.  
It's a good idea to check your code diffs before putback ('$ME pdiffs').

Also, run '$ME $command -n' and check for conflicts before doing the
final putback.
			EOF

			if [[ -z "$(wx_summary -bo 2>/dev/null)" ]]; then
				cat <<-EOF

Don't forget the ARC ID info in your active list comments if there is an
ARC case associated with your putback.
				EOF
			fi

			echo "\nThe putback comment will be:"
			cat $wxtmp/pb_comments
			print "========== End of putback comments ======="

			# Output warning if RTI isn't approved.
			wx_rtichk $nolookup
			print "========== End of RTI check output ======="

			cat <<-EOF

The following files will be used for putback:
$pbfiles

			EOF
			) | ${PAGER:-more}

			ok_to_proceed "Do you really want to"\
				"'$PUTBACK ${pbargs[@]}' to $parent?"
		fi
	fi

	# Do the putback, passing in active list comments if required.
	# putback both active and renamed/deleted files.
	cd $workspace
	if $narg; then
		# Don't use putback comment if -n is given (trial putback)
		$PUTBACK "${pbargs[@]}" $pbfiles
	else
		# feed active list comments into real putback
		wx_summary $verbatim $nolookup |$PUTBACK "${pbargs[@]}" $pbfiles
	fi
	return
}

outchk() {

	# List files that are checked out but not in active list.
	typeset outfile do_header=true

	wx_checked_out >/dev/null
	# if $wxtmp/checked_out is 0 bytes then return
	[[ -s $wxtmp/checked_out ]] || return

	sort $wxtmp/checked_out > $wxtmp/co_sort
	wx_active | sort > $wxtmp/active_sort
	for outfile in $(comm -12 $wxtmp/active_sort $wxtmp/co_sort); do
		if $do_header; then
			echo "\nWarning, the following active list files are"\
			    "checked out:"
			do_header=false
		fi
		echo "$outfile"
	done
	do_header=true
	for outfile in $(comm -13 $wxtmp/active_sort $wxtmp/co_sort); do
		if $do_header; then
			cat <<-EOF

Warning, the following files are checked out but not in active list
(Run "$ME update -q" to add them to the active list): 
			EOF
			do_header=false
		fi
		echo "$outfile"
	done
	rm -f $wxtmp/co_sort $wxtmp/active_sort
}

#
# run Teamware resolve and do reedit only on merged files.
#
wx_resolve() {
	typeset merged_file

	# clear the file_list, will be set below
	file_list=

	grep -v '^VERSION ' $wsdata/conflicts > $wxtmp/conflicts
	[[ ! -f $wxtmp/conflicts ]] && fail "Error: cannot create $wxtmp/conflicts"

	# run Teamware resolve
	resolve $* || fail "Teamware resolve failed."

	# resolve will remove files from $wsdata/conflicts when
	# successfully merged.

	# set file_list to files that were merged.
	for merged_file in $(cat $wxtmp/conflicts); do
		if ! grep -q '^'"$(escape_re $merged_file)"'$' \
		    $wsdata/conflicts; then
			# set file_list for wx_eval later.
			file_list="$file_list $merged_file"
		fi
	done

	if [[ -n $file_list ]]; then
		ok_to_proceed "Re-edit merged files to collapse merge deltas?"
		echo "Re-editing merged files"
		echo
		wx_eval wx_reedit_file
		echo
		echo "Re-edit complete"
		echo
	else
		echo "No merged files to re-edit."
	fi
}

#########################################################################
#
# Main
#

#
# Do some initial sanity checking and set up.
#

# Set the lang to standard English so wx doesn't get confused.
export LC_ALL=C

# Turn on debugging output early
if [[ "$*" == *' -D'*( *) ]]; then
	typeset -ft $(typeset +f)
	set -x
fi

ME=$(basename $0)
export ME

if [[ -d /usr/xpg4/bin ]]; then
	# Want to use xpg4 versions of fgrep and grep
	PATH=/usr/xpg4/bin:/usr/bin:/usr/sbin:/usr/ccs/bin:$PATH
else
	fail "Error: directory /usr/xpg4/bin not found."
fi

unset CDPATH	# if set "cd" will print the new directory on stdout
		# which screws up wx_eval.

DEFAULT_SRCDIR=usr

if [[ $# -eq 0 || "$1" == help ]]; then
	# output usage now to avoid unnecessary checking below.
	wx_usage
fi

if [[ "$1" == version ]]; then
	# output version now to avoid unnecessary checking below.
	version
	exit 0
fi

#
# Check to make sure we're not being run from within a Mercurial repo
#
if hg root >/dev/null 2>&1; then
	fail "Error: wx does not support Mercurial repositories.\n"\
"Please see http://opensolaris.org/os/community/tools/hg"
fi

whence workspace >/dev/null || fail "Error: cannot find workspace command in \$PATH."

# Note, PUTBACK can be set to "cm_env -g -o putback" to use Casper Dik's
# turbo-dir.flp scripts to speed up thorough updates.
PUTBACK=${PUTBACK:='putback'}
BRINGOVER=${BRINGOVER:='bringover'}

dot=$PWD

if [[ -n "$CODEMGR_WS" ]]; then
	# ws was used.
	# normalize the workspace name.
	workspace=$(cd $CODEMGR_WS && workspace name)

	# If the current dir is in a workspace check that it is the same
	# as CODEMGR_WS.
	if [[ -n "$(workspace name)" ]]; then
		if [[ "$(/bin/pwd)/" != "$workspace/"* ]]; then
			cat <<-EOF

Warning, $ME will use $ME files in workspace $workspace (the current
directory is not in this workspace).
			EOF
			ok_to_proceed "Okay to proceed?"
		fi
	fi
else
	# If current dir is in a workspace then use output of workspace
	# name as current ws.
	workspace=$(workspace name)
	if [[ -n "$workspace" ]]; then
		CODEMGR_WS=$workspace
		export CODEMGR_WS
	fi
fi

if [[ -z "$workspace" ]]; then
	fail "No active workspace, run \"ws <workspace>\" or"\
		"\"cd <workspace>\"."
fi

workspace_basename=`basename $workspace`
wxdir=${WXDIR:-$workspace/wx}
wxtmp=$wxdir/tmp
wsdata=$workspace/Codemgr_wsdata
node=`uname -n`

if [ -f $wsdata/parent ]; then
	parent=`tail -1 $wsdata/parent`
else
	parent=
fi
if [[ $parent == *:* ]]; then
	parentdir=${parent#*:}
	parentnode=${parent%%:*}
	if [[ $parentnode == $node ]]; then
		parent=$parentdir
	else
		parent=/net/$parentnode$parentdir
	fi
fi

# Store backup state
backup_done=0

# store state if new files are deleted
NEED_WS_CLEAN='n'

# XXX doing this because keywords doesn't work on new files
# Note doing the echo so the tabs are apparent,
# % is escaped to prevent keyword expansion by sccs commands on this file.
SCCSKEYWORD=$(echo "ident\t+\"(\%Z\%\%M\%\t+\%I\%|\%W\%)\t+\%E\% SMI\"")

# file that contains comments for use in create and checkin
comment_file=
# mode for updating comments in active list
comment_mode="replace"

CSTYLE_FLAGS=${CSTYLE_FLAGS:='-P -p -c'}
JSTYLE_FLAGS=${JSTYLE_FLAGS:='-p'}

BACKUP_ERRORS=/tmp/${ME}_berrors_$(/usr/xpg4/bin/id -un)_$$

# global for reedit command, don't checkin by default
CHECKIN=false

# Indicates that the parent nametable cache needs refreshing
need_pnt_refresh=true

# Indicate whether file args were specified
FILES_PASSED=false

# Used to store files that have more than one delta compared to parent
multi_delta_list=

# Used to bringover any files just before exit of wx
bofilelist=

# should codereviews include delta comments?
show_comments=true

# Determines if active list should be sorted by default
# If sort_active contains true then we sort the active list on updates.
if [[ -r $wxdir/sort_active && "$(cat $wxdir/sort_active)" == "true" ]]; then
	ACTSORT=sort
else
	ACTSORT=cat
fi

# These are set depending on what needs sorting
do_renamed_sort=false
do_active_sort=false

# Places to search for approved RTIs
RTIDIRS="/net/wizard.eng/export/consolidation/rtiroute/newrtis
	/net/wizard.eng/export/consolidation/rtiroute/oldrtis
	/net/onstc.eng/export/stc/Rtitool/consolidation/rtiroute/newrtis
	/net/onstc.eng/export/stc/Rtitool/consolidation/rtiroute/oldrtis"

# Places to search for approved Patch RTIs
PRTIDIRS="/net/wizard.eng/export/consolidation/rtiroute/newprtis
	/net/wizard.eng/export/consolidation/rtiroute/oldprtis"

export workspace parent wxdir file dir filepath backup_done DEFAULT_SRCDIR

#
# main section
#

# Get wx command
command=$1
comlist=$command
shift
# throw away -D flag after command assigned as this flag was processed earlier
[[ "$1" == '-D' ]] && shift

case $command in
	apply|eval)	subcommand=$1; shift;;
	grep|egrep|sed|nawk)	pattern=$1; shift;;
	nits)	comlist="cstyle jstyle hdrchk copyright cddlchk keywords";
		echo "Note, nits is a subset of pbchk checks.";;
	pbchk)	comlist="cstyle jstyle hdrchk copyright cddlchk keywords"
		comlist="$comlist rmdelchk deltachk comchk rtichk outchk";;
esac

orig_args="$@"
silent=
args=
file_list=
typeset tmp_file_list tmp_args

#
# Some subcommands pass through all arguments.
#
case $command in
	webrev)	args="$orig_args"; shift $#;;
esac

# Parse args
while [ $# -gt 0 ]; do
	case $1 in
		-c|-C)
			if [[ $command == @(delget|checkin|ci|create) ]]; then
				# set global comment_file
				[[ "$1" == "-C" ]] && comment_mode="append"
				comment_file=$2;
				if [[ $comment_file != '/'* ]]; then
					comment_file="$(pwd)/$comment_file"
				fi
				if [[ -z "$comment_file" ]]; then
					fail "Missing comment file."\
						"Run 'wx help' for info."
				fi
				[[ ! -r "$comment_file" ]] &&
				    fail "Can not read comment file"\
				    	"$comment_file."
				echo "Using comment file $comment_file"\
					"for comments."
				# shift past the comment_file arg
				shift
			elif [[ $1 == '-C' && $command == 'diffs' ||
				$command == 'tdiffs' &&
				-z $WXDIFFCMD ]]; then
				if [[ $2 != +([0-9]) ]]; then
					# provide default context value for
					# compat with old wx
					args="$args -C5"
				else
					args="$args -C$2"
					# shift past context lines arg
					shift
				fi
			else
				args="$args $1"
			fi;;
		-p) 	if [[ $command == @(putback|pb) ]]; then
				if workspace access $2 >/dev/null; then
					# 2nd arg is a workspace
					args="$args $1 $2"
				else
					fail "$2 not a workspace."\
						"Run 'wx help' for info."
				fi
				# shift past the parent ws arg
				shift
			else
				# for other commands -p doesn't have a arg
				args="$args $1"
			fi;;
		-r) 	if [[ $command == @(get|extract) ]]; then
				# 2nd arg is the version #
				args="$args $1 $2"
				# shift past 2nd arg
				shift
			else
				# for other commands -r doesn't have a arg
				args="$args $1"
			fi;;
		-s) 	if [[ "$command" == @(update|init) ]]; then
                                args="$args $1"
                        else
                                silent=-s
                        fi;;
		-N)	if [[ "$command" == @(codereview|fullreview) ]]; then
				show_comments=false
			else
				args="$args $1"
			fi ;;
		-*) 	args="$args $1";;
		*)  	if [[ -z "$file_list" ]]; then
				file_list="$1"
			else
				file_list="$file_list $1"
			fi;;
	esac
	shift
done

if [[ "$command" == "init" ]]; then
	if [ -z "$file_list" ]; then
		file_list=$DEFAULT_SRCDIR
	fi
	wx_init $file_list $args
	exit
fi

if [ ! -d $wxdir/tmp ]; then
	echo "Workspace does not appear to be initialized for $ME."
	echo "The initialization process will create a few files under"
	echo "$wxdir but will not otherwise affect your workspace."
	ok_to_proceed 'OK to proceed?'

	ask "Where is the root of the source code in this workspace?" \
		$DEFAULT_SRCDIR
	# wx_init modifies file_list so save current value
	tmp_file_list=$file_list
	file_list=
	# save off args and set to null to avoid side effects
	tmp_args=$args
	args=
	wx_init $answer
	# restore original file list and cd to original dir in case there's
	# a command to execute.
	file_list=$tmp_file_list
	args=$tmp_args
	cd $dot
fi

if [[ ! -f $wxdir/local_nametable ]]; then
	touch $wxdir/local_nametable
fi

# Doing this for backward compat since old wx doesn't have a renamed list
if [[ ! -f $wxdir/renamed ]]; then
	# if 'wx update' or 'wx update -r' is the command then skip
	# renamed list creation since it will happen anyway.
	if [[ "$command" != "update" ]] || [[ "$args" == *'-q'* ]]; then
		ring_bell
		cat <<-EOF

$ME needs to create a renamed file list.  If you are sure that no files
were renamed or deleted in the current workspace then answer no to the
following question.

		EOF
		yesno "Okay to search for renamed files (can be slow)?"
		if [[ "$answer" == "yes" ]]
		then
			wx_update -r
		else
			touch $wxdir/renamed
		fi
	fi
fi

# Doing this for backward compat since old wx doesn't have a new list
if [[ ! -f $wxdir/new ]]; then
	ring_bell
	cat <<-EOF

$ME needs to create a new-file list (cache names of newly created
files).  Please be patient.
	EOF
	# Avoid a putback -n which is slow, just use lookup_parent()
	touch $wxdir/new || fail "Error: cannot create $wxdir/new list"
	wx_active |
		while read filepath; do
			if ! lookup_parent $filepath; then
				add_new $filepath
			fi
		done
	echo "\nNew files:"
	cat $wxdir/new
	echo
fi

if [[ "$command" == @(restore|backup|bu) ]]; then
	# If the backup dir was specified as a file arg...
	if [ -n "$file_list" ]; then
		backup_dir=$(echo "$file_list"|cut -f1 -d' ')
	fi
	# unset file_list since this file arg has been processed here.
	unset file_list
elif [[ "$command" == "ea" ]]; then
	# Do this command before wx_active is run because the active list
	# may be corrupt.
	cd $wxdir
	exec ${EDITOR-vi} active
elif [[ "$command" == @(unedit|uncheckout|unco) ]]; then
	if [[ -z "$file_list" && $args != *-f ]]; then
		echo "$ME will $command all active files which may remove"\
		    "them from the active list."
		ok_to_proceed 'Do you REALLY want to do this?'
	fi
	cp $wxdir/active $wxdir/active.old
elif [[ "$command" == @(bugs|arcs) ]]; then
	# -v verbatim is not valid for these commands
	if [[ "$args" == *'-v'* ]]; then
		fail "Invalid flag -v. Run 'wx help' for info."
	fi
elif [[ "$command" == "create" ]]; then
	if [ -z "$file_list" ]; then
		fail "$command missing file arg(s). Run 'wx help' for info."
	fi

	cp $wxdir/active $wxdir/active.old ||
		fail "Error could not backup $wxdir/active"
elif [[ "$command" == @(delget|checkin|ci) && -n "$comment_file" ]]; then
	cp $wxdir/active $wxdir/active.old ||
		fail "Error could not backup $wxdir/active"
elif [[ "$command" == @(mv) ]]; then
	if [[ $(echo "$file_list"|wc -w) -ne 2 ]]; then
		fail "$command requires two args. Run 'wx help' for info."
	fi

	cp $wxdir/active $wxdir/active.old ||
		fail "Error could not backup $wxdir/active"
	cp $wxdir/renamed $wxdir/renamed.old ||
		fail "Error could not backup $wxdir/renamed"
elif [[ "$command" == @(delete|rm) ]]; then

	if [ -z "$file_list" ]; then
		echo "$ME will try to delete all active files which may "\
		    "remove them from the active list."
		ok_to_proceed 'Do you REALLY want to do this?'
	fi

	cp $wxdir/active $wxdir/active.old ||
		fail "Error: could not backup $wxdir/active"
	cp $wxdir/renamed $wxdir/renamed.old ||
		fail "Error: could not backup $wxdir/renamed"
elif [[ "$command" == reset ]]; then
	cp $wsdata/nametable $wxtmp/nametable.orig || \
		fail "Error: cp $wsdata/nametable $wxtmp/nametable.orig failed."
fi

if [ -z "$file_list" ]; then
	basedir=$workspace
	file_list=$(wx_active) || fail
else
	base_file_list=$file_list
	file_list=
	for basefile in $base_file_list; do
		# normalize the filepaths
		if [[ -d $basefile ]]; then
			basedir=$(cd $basefile && /bin/pwd)
			abspath=$basedir
		else
			basedir=$(cd $(dirname $basefile) && /bin/pwd)
			abspath=$basedir/$(basename $basefile)
		fi
		if [[ ! -d $basedir ]]; then
			fail "Error: Path to $basefile does not exist."
                elif [[ $(cd $basedir; workspace name) != $workspace ]]; then
			fail "Error: $basefile isn't in current workspace: $workspace."

		fi
		filepath=${abspath##$workspace/}
		if [[ -z "$file_list" ]]; then
			file_list="$filepath"
		else
			file_list="$file_list $filepath"
		fi
	done
	FILES_PASSED=true
fi

if [[ "$command" == @(nits|pbchk) ]]; then
	tmp_list=
	# skip nits/pbchk checks for files listed in $command.NOT
	if [[ -f $wxdir/${command}.NOT ]]; then
		for _a_file in $file_list; do
			if grep -q "^$(escape_re $_a_file)$" \
				$wxdir/${command}.NOT
			then
				echo "skipping $command checks for "\
				    "$_a_file (skipping)"
			else
				tmp_list="$tmp_list $_a_file"
			fi
		done
		file_list=${tmp_list# }
	fi
	[[ -z $file_list ]] && exit 0
fi

# This is where the commands are executed.
for command in $comlist; do
cd $dot
case $command in
	list|active) wx_active $args ;;
	pblist)	wx_active -p;;
	renamed)	list_renamed $args ;;
	new)	list_new $args;;
	update)	wx_update $args;;
	out)	wx_checked_out; cat $wxtmp/checked_out;;
	diffs)	wx_eval -r 'print -- "\n------- $filepath -------\n";
			sccs get -s -p -k $filepath |
			${WXDIFFCMD:-diff} $args - $filepath';;
	tdiffs)	## As diffs but also shows new files.
		if [[ -r $wxdir/new ]]; then
		    ## Read names of new files into space separated list.
		    while read new_file
		    do
			new_files="${new_files}${new_file} "
		    done < $wxdir/new
		else
		    new_files=""
		fi
		## For new files a comparison is made with /dev/null thus
		## all lines will appear to have been added.
		wx_eval -r 'print -- "\n------- $filepath -------\n";
		    if [[ ${new_files} == *"${filepath} "* ]]; then
			${WXDIFFCMD:-diff} $args /dev/null $filepath;
		    else
			sccs get -s -p -k $filepath |
			${WXDIFFCMD:-diff} $args - $filepath;
		    fi';;
	pdiffs|tpdiffs)
		## Parent Diffs - Compare with parent file.  For
		## 'tpdiffs' when the parent file does not exist the
		## child file is assumed new and compared to
		## /dev/null; thus all lines will appear to have been
		## added.
		wx_eval '
		print -- "\n------- $filepath -------\n";
		if wx_pnt_filepath; then
			echo "Index: $filepath";
			${WXDIFFCMD:-diff} $args $parentfilepath
			    $workspace/$filepath;
		    elif [[ $command == 'tpdiffs' ]]; then
			${WXDIFFCMD:-diff} $args /dev/null
			    $workspace/$filepath;
		    else
			print "New file (does not exist in parent).";
		    fi';;
	pvi)	wx_eval '
		echo $filepath;
		if wx_pnt_filepath; then
			${EDITOR-vi} $args $parentfilepath;
		else
			echo "New file (does not exist in parent)";
		fi';;
	edit|checkout|co)	wx_eval wx_edit;;
	unedit|uncheckout|unco)	wx_eval wx_unedit;;
	create)		wx_eval wx_create $args;;
	uncreate)	wx_eval wx_uncreate $args;;
	delete|rm)	wx_eval wx_delete $args;;
	mv)		wx_mv $file_list;;
	delget|checkin|ci)	wx_eval wx_delget $args;;
	get|extract)	wx_eval wx_get;;
	reset)		wx_eval wx_reset $args;;
	putback|pb)	wx_putback $args;;
	resolve)	wx_resolve $args;;
	prt)		wx_eval 'sccs prt $args $file';;
	comments)	wx_eval 'echo $filepath; echo; wx_show_comment; echo';;
	bugs)   wx_summary -ao $args;;
	arcs)   wx_summary -bo $args;;
	pbcom)  wx_summary -po $args;;
	info)	wx_eval wx_info;;
	reedit|recheckout|reco)  wx_reedit $args;;
	redelget|recheckin|reci) CHECKIN=true; wx_reedit $args;;
	cstyle) echo "\nDoing cstyle check:"
		rm -f $wxtmp/wx.cstyle.*;
		export CSTYLE_INDEX=0;
		wx_eval wx_cstyle;
		wait;
		sort -k 1,1 -k 2,2n $wxtmp/wx.cstyle.* 2> /dev/null
		;;
	jstyle) echo "\nDoing jstyle check:"
		rm -f $wxtmp/wx.jstyle.*;
		export JSTYLE_INDEX=0;
		wx_eval wx_jstyle;
		wait;
		sort -k 1,1 -k 2,2n $wxtmp/wx.jstyle.* 2> /dev/null
		;;
	hdrchk)	echo "\nDoing header format check:";
		cd $workspace;
		hdrchk_files=;
		for filepath in $file_list ; do
			if [[ "$filepath" == *.h ]]; then
				if [[ -s $wxdir/${command}.NOT ]] &&
					grep -q "^$(escape_re $filepath)$" \
						$wxdir/${command}.NOT
				then
					echo "$filepath (skipping)"
				else
					hdrchk_files="$hdrchk_files $filepath"
				fi
			fi
		done
		hdrchk -a $args $hdrchk_files ;;
	makestyle) echo "\nDoing makestyle check:";
		cd $workspace; mlist=$(wx_active | grep '[Mm]akefile');
		[[ -n "$mlist" ]] && makestyle $args $mlist;;

	keywords)
		echo "\nDoing keywords check:";
		cd $workspace;
		keyword_files=;
		for filepath in $file_list ; do
			if [[ -s $wxdir/${command}.NOT ]] &&
				grep -q "^$(escape_re $filepath)$" \
					$wxdir/${command}.NOT
			then
				echo "$filepath (skipping)"
			else
				keyword_files="$keyword_files $filepath"
			fi
		done
		keywords -p $args $keyword_files;;

	rmdelchk) echo "\nDoing sccs rmdel check:"; wx_eval rmdelchk;;

	rtichk) wx_rtichk;;

	deltachk)  echo "\nDoing multi delta check:"; wx_eval deltachk;;
	copyright) echo "\nDoing copyright check:";
		cd $workspace;
		copyright_files=;
		for filepath in $file_list; do
			if [[ -s $wxdir/${command}.NOT ]] &&
				grep -q "^$(escape_re $filepath)$" \
					$wxdir/${command}.NOT
			then
				echo "$filepath (skipping)"
			else
				copyright_files="$copyright_files $filepath"
			fi
		done
		copyrightchk $copyright_files;;

	cddlchk)
		echo "\nDoing CDDL block check:";
		cd $workspace;
		cddlnot="";
		if [[ -s $wxdir/${command}.NOT ]]; then
			cddlnot="-x $wxdir/${command}.NOT"
		fi

		#
		# Split the file list into new files and existing files.
		# New files must have a CDDL block whereas existing files don't
		# necessarily have to have a block, but if they do it must be
		# valid.  Both sets of files are subject to cddlchk.NOT
		# exception processing.
		#
		old=""
		new=""
		for filepath in $file_list; do
			if wx_pnt_filepath $filepath; then
				old="$old $filepath"
			else
				new="$new $filepath"
			fi
		done
		[[ ! -z $new ]] && cddlchk $cddlnot $args -a $new
		[[ ! -z $old ]] && cddlchk $cddlnot $args $old
		;;
	comchk)	 echo "\nDoing comments check:"; wx_summary -n 2>&1;;
	outchk)	 echo "\nDoing out check:"; outchk;;
	backup|bu) wx_backup $args;;
	restore) wx_restore $args;;
	apply)	wx_eval "$subcommand \$file";;
	eval)	wx_eval "$subcommand";;
	grep|egrep)
		   wx_eval '
		   if egrep -s '\'$pattern\'' $file;
		   then
			   echo $filepath;
			   $command $args '\'$pattern\'' $file;
		   fi';;
	nawk|sed)
		wx_eval 'echo $filepath; $command $args '\'$pattern\'' $file';;
	codereview) args="-e $args"; wx_eval wx_fullreview;;
	fullreview) wx_eval wx_fullreview;;
	webrev) wx_webrev $args;;
	dir)	echo $wxdir;;
	e)	cd $wxdir; exec ${EDITOR-vi} $orig_args;;
	ws)	cd $wsdata; cat $orig_args;;
	args)	cat $wsdata/args;;
	access)	cat $wsdata/access_control;;
	*)	ring_bell;
		echo "Command not found. Run 'wx help' for command list.";
		exit 1;;
esac

done

if [[ $NEED_WS_CLEAN == 'y' ]]; then
	# clean up the nametable
	print -u2 "Running workspace updatenames to clean up nametable, may"\
	    "take a while."
	workspace updatenames >&2
fi

if [[ -n $bofilelist ]]; then
	$BRINGOVER $bofilelist
fi

# save sorting for last for some speed up.
if [[ $ACTSORT == sort ]]; then
	if $do_renamed_sort; then
		sort_renamed
	fi
	if $do_active_sort; then
		sort_active
	fi
fi