# File: cdx
# ----------------------------------------------------------------------------
# Function:     cdLimitList   
# Purpose:      Chops off the tail of DIRLIST, if needed, to prevent the list 
# from growing to more than 10.   
# Returns:      true (0)        
# Arguments:    None
# ............................................................................
cdLimitList()
{
    local tempStr=${DIRLIST//[!\\]/} # Compress to all (suffix) delimiter.
    if [ ${#tempStr} -gt 10 ] ; then
        DIRLIST="${DIRLIST%\`*\\}" # Remove the tail.
    fi
}

# ----------------------------------------------------------------------------
# Function:     cdInList
# Purpose:      Determines whether the given directory ($1) is in the DIRLIST.
# Returns:      1 if the directory is in the list else 0. 
# Arguments:    $1 is the directory to try to find in the list.
# ................................. Notes ....................................
# It does this by comparing the list string length before and after attempting 
# to remove the directory. The dir list itself is not changed in any case. 
# ............................................................................
cdInList()
{
    local lvCnt=${#DIRLIST}
    local lvDirs="${DIRLIST//\`${1}\\}"
    return $(($lvCnt != ${#lvDirs}))
}

# ----------------------------------------------------------------------------
# Function:     cdForBack
# Purpose:      Implements the -f and -b commands to move forward and backward 
# through the directory list. -f moves to the list tail directory and - b to 
# the head. If PWD is not already in the list, it is added to the head if -f or 
# tail if -b.
# Returns:      error (NZ) if DIRLIST is empty else reflected return from 
# builtin cd.
# Arguments:    $1 is F to move forward through the list or B (or any non-F)
# to move backward.
# ................................. Notes ....................................
# This always calls builtin cd unless DIRLIST is empty.
# ............................................................................
cdForBack()
{
    local dir
    if [ -n "$DIRLIST" ] 
    then
        cdInList $PWD
        local lvPwdInList=$?
        if [ $lvPwdInList -eq 0 ] ; then
            cdLimitList 
        fi 
        if [ $1 = 'F' ] ; then # forward
            dir="${DIRLIST##*\`}" # Tail is forward target.
            dir="${dir%\\}"
            DIRLIST="${DIRLIST%\`*\\}" # Rotate right, losing tail
            if [ $lvPwdInList -eq 0 ] ; then
                DIRLIST="\`${PWD}\\$DIRLIST"
            fi
        else # backward
            dir="${DIRLIST%%\\*}" # Head is backward target.
            dir="${dir#\`}"
            DIRLIST="${DIRLIST#\`*\\}" # Rotate left, losing head
            if [ $lvPwdInList -eq 0 ] ; then
                DIRLIST="$DIRLIST\`${PWD}\\"
            fi
        fi
        builtin cd "$dir" 
        return # Be sure to reflect return from builtin cd (although fi won't change it).
    fi # [ -n "$DIRLIST" ]
}

# ----------------------------------------------------------------------------
# Function:     cdRotateList  
# Purpose:      Rotates the directory list to move the given directory ($1) to 
# the head. Do not call this without first ascertaining that the directory is 
# in the list or else this will run forever.
# Returns:      true (0)
# Arguments:    None
# ............................................................................
cdRotateList()
{
    local dir
    while dir=${DIRLIST%%\\*} ; [ "$dir" != "\`${1}" ] ; do
        DIRLIST=${DIRLIST#*\\}"$dir\\"
    done
}
    
# ----------------------------------------------------------------------------
# Function:     cd
# Purpose:      Front end over builtin cd.      
# Returns:      Reflected return from builtin cd in most cases but always true 
# (0) if command argument is -c or -s and the user aborts (^C). If -f, -b, or -s 
# and DIRLIST is empty then false (NZ).
# Arguments:    $1 is -h/H, -f/F, -bB, -cC, -s/S or a directory name. 
# ............................................................................
cd()
{
    if [ -z $CDINIT ] ; then
	CDINIT=1
	trap savedirlist EXIT
	if [ -e ~/.DirList ] ; then
	    DIRLIST="$(cat ~/.DirList)"
	    if [ "$1" = "" ] ; then
		local dir="${DIRLIST%%\\*}" 
		dir="${dir#\`}"
  		builtin cd "$dir"
		return
	    fi
	fi
    fi

    case "$1" in

    -h | -H | -\? ) 
        echo 'cd front end: -b backward, -f forward, -s select from menu, -c clear'
	userinp=''
	read -p '1) cd help 2) help cd <enter> ' userinp
	case $userinp in
	    1) builtin cd --help ;;
            2) help builtin cd ;;
	esac
        return 
        ;; #  case -h | -H | -\?

    -f | -F ) # ----- Move forward through dir list --------
        cdForBack F 
        return 
        ;; # case -f | -F 

    -b | -B ) # ------ Move  backward through dir list --------
        cdForBack B 
        return 
        ;; # case -b | -B 
        
    -c | -C ) # ------ Clear dir list ----------------
	DIRLIST=
        return 0 
        ;; # case -c | -C

    -s | -S ) # ---------- Select from directory list ---------
# If PWD isn't already in the list then add it to the head. Checking for its 
# inclusion in the list and adding it are done in the same statement by 
# removing it if it in in the list and unconditionally adding it. This would 
# also have the effect of moving it to the head if it were in the list and not 
# at the head, potentially changing the order. This situation can exist only
# if the user has typed the name of a directory that is already in the list.
        DIRLIST="\`${PWD}\\${DIRLIST//\`${PWD}\\/}" 
        IFS=\`
        PS3="Select directory or ^C to stay in $PWD > "
        local dirlist="${DIRLIST//\\/}"
        local err="0"
        select seldir in ${dirlist#\`} ; do
            if [ "$seldir" ] ; then 
                cdRotateList "$seldir"
                cdForBack B
                err=$?
            fi
            break
        done # select seldir
        unset IFS
        unset PS3
        return $err 
        ;; #  case -s | -S

    * ) # -------- Normal cd but always push departing dir  onto list ---------
# If a directory already in the list is typed, nothing special will happen
# immediately because we don't do anything immediately with the target anyway.
# However, on leaving the directory, its name is moved from its previous position
# in the list to the head.
        if [ "$1" != "$PWD" ] ; then
            local dir="$PWD"
            builtin cd $1 $2 $3 # $1 must not be quoted or blank (home) fails.
            local err=$?
            if [ $err = "0" ]
            then
# If the list is empty then it becomes simply the pre-cd PWD. Otherwise,
# put pre-cd PWD at the head. 
                if [ -z "$DIRLIST" ] ; then
                    DIRLIST="\`$dir\\" 
                else
                    DIRLIST="\`${dir}\\${DIRLIST//\`${dir}\\/}"
                fi
                cdLimitList
                return 0
            else # cd failure
                return $err # Reflect return from builtin cd
            fi # if cd
        fi # [ "$1" != "$PWD" ]
        ;; # case *
    esac # case $1 in
}

# ----------------------------------------------------------------------------
# Function:     savedirlist
# Purpose:      Shell on-exit callback. Move or add the closing directory to
# the head of DIRLIST and write the list out to ~/.DirList.
# .......................... Notes .........................................
#                        Closing Directory
# There are two reasons for move/add the closing directory. Directories are 
# added to the list only when we leave them. Unless we are revisiting the 
# closing directory, it won't be in the list. Also, we want the closing 
# directory at the head of the list (which is normally done by remove/insert) 
# to make it easy to extract at the beginning of the next session to assist 
# opening a fresh terminal at the closing directory of the previous.
# ............................................................................
savedirlist()
{
    DIRLIST="\`${PWD}\\${DIRLIST//\`${PWD}\\/}"
    echo "$DIRLIST" > ~/.DirList
}

# File: findtext
# Search text files for a given case-insensitive string.
# Usage: findtext searchString findArgs
# findtext invokes find, passing it all arguments after the first. On every 
# matching file find -exec invokes findiftext, which, if the file is text, 
# invokes grep to search for the string in it.
# ..................... notes ...............................................
# The companion script findiftext must be executable because find -exec won't 
# source a script. findtext could be sourced but that would just make it more 
# difficult for the user to invoke. The slight invocation time improvement 
# would be immaterial beause it is just invoked one time for a complex process.
# .............................................................................

if test "$1" = "" ; then echo Text argument is missing. ; exit -1 ; fi 
set -f # Disable path globbing to simplify script and use syntax.
echo Search for \"$1\" in text files found by find ${@:2} 
find ${@:2} -type f -exec findiftext "$1" {} \;

#!/bin/bash
# xdif
# This script is an improved version of the standard diff utility. The main 
# improvement is to provide regular recursion. diff treats subdirectories as if 
# they were files, reporting content differences but not differences between 
# the file themselves. Files are compared only in the root directories 
# (arguments to diff). xdif corrects this by providing its own recursion, 
# reinvoking diff at each level. xdif also affords more reporting options than 
# diff, including 
#- whether to report each directory change when recursing
#- whether to report missing directories when recursing
#- whether to report missing files.
#- whether to report "Permission denied" files.
# ............... notes ..........................................
#            diff output filters
# "Permission denied" and missing files are filtered out by piping diff into 
# grep. Diff sends these messages to stderr instead of stdout, so they could be 
# filtered by redirection 2> /null/def. In fact, to present a unified stream of 
# diff's normal and error output to grep requires redirection 2>&1
# ---------------------------------------------------------------------------

# ------------------------------------------------------------------------------
# Function: filterDif
# Purpose:  This is the core. Given two filespecs, it invokes diff on each file
# in $1 compared to the presumed corresponding file in $2. For each directory
# in $1, if recursion is turned on, filterDif calls itself. 
# Returns:  Nothing
# Arguments:
# - $1 is the reference or source  directory. Its files (and subdirectories if 
# recursing) are the ones chosen for comparison. 
# - $2 is the comparison or destination directory. 
# Files that exist under $1 but not under $2 are reported as missing (unless
# option -f). Files that exist under $2 but not under $1 are ignored.
# Globals: 
# - patterns is an array of file filter patterns, e.g. "*.cpp" 
# - patternCnt tells the number of elements in patterns. There is always at least
# one. If the script is invoked without patterns then patterns is assigned one
# element "*". This simplifies filterDif a bit.
# ........................ notes ..............................................
#                        GREP -F -P
# Diff's output is piped to grep only if the -f or -p filter is turned on. Grep 
# is not need for -i (Identical) filtering.
#
#                        FILES VS DIRECTORIES
# In each invocation (initial and recursive) iterate over files first and then,
# if recursive, directories. This not only produces a less confusing output but
# simplifies handling filter patterns. It would be difficult to merge files
# and directories into one loop because directories, not being subject to 
# filtering, can only be iterated over by *. But then the only way to determine
# whether to skip a file due to filtering would be to, for each file, iterate
# over the filter list. It is much simpler to, for each filter pattern, iterate
# over the files in the current source directory 
# .............................................................................
filterDif()
{
    if [ -n "$announceDirs" ] ; then
        echo "Diff ${patterns[@]} files in $1 to $2" 
    fi

# First iterate over all files (in $1 = source directory) over all patterns.
# If no file filter pattern then the pattern list comprises just "*".
    for (( idx=0 ; idx < $patternCnt ; idx++ )) ; do
        for f in $1/${patterns[$idx]} ; do
# For some unknown reason, if the directory doesn't contain any file matching
# a wildcard pattern, the interpreter makes one f that is the same as the 
# pattern, e.g. *.h. So we need to verify the file's existance before using
# it. We needed to do this anyway to avoid matching directories at this stage.
# Note that both invocations of diff redirect stderr to stdout. When piping
# to grep this is essential, but it is useful in the other case as well, so
# that the output can be directed into a file.
            if [ -f "$f" ] ; then
                if [ "$grepArg" ] ; then
                    diff $diffArg $f "$2" 2>&1 | eval egrep $grepArg\"
                else
                    diff $diffArg $f "$2" 2>&1 
                fi
            fi
        done
    done

# Now, if recursive, iterate over all names (*) in the source directory and
# recurse on each directory for which there is a matching destination.
    if [ -n "$recurse" ] ; then
        for f in "$1"/* ; do
            if [ -d "$f" ] ; then
                dir="$root2${f/#$root1/}"
                if [ -d "$dir" ] ; then
                    filterDif "$f" "$dir"
                elif [ -z "$noMissDirs" ] ; then
                    echo "Directory $dir does not exist" 
                fi # if [ -d "$dir" ]
            fi # if [ -d "$f" ]
        done # for f in "$1"/*
    fi
}

# -----------------------------------------------------------------------------
# Function: grepExclude
# Purpose:  Called when command line parsing finds an option that requires 
# grep (-f or -p). On the first invocation, it sets up the basic grep 
# argument '-v "' and the given filter string. On subsequent invocation it just 
# adds the filter string. Additional filters may be added in the future but 
# with only -f and -p the maximum resulting value is '-v "(No such)|(Permission 
# denied)"
# Returns:  Nothing
# Arguments: $1 is a string filter, e.g. "No such" or "Permission denied", which
# added to the grepArg variable, whose value comprises command arguments passed
# to grep (if command arguments to xdif trigger a need for grep).
# Globals: assigns grepArg
# ..............................................................................
grepExclude()
{
    if [ "$grepArg" ] ; then 
        grepArg="$grepArg|($1)"
    else
        grepArg="-v \"($1)"
    fi
}

# -----------------------------------------------------------------------------
# Function: tellUse
# Pupose:   Tells basic usage. If called in response to an error, the caller
# should explain the error.
#..............................................................................
tellUse()
{
    echo "Usage: xdif [-radsifphH] [fileset1] fileset2 'filter' 'filter' ..."
    echo "Show differences between fileset1 and fileset2."
    echo "Empty fileset1 defaults to all PWD files."
    echo "Filters limit selected files. e.g. '*.c'."
    echo "Options:"
    echo "-s Show file difference details"
    echo "-r Recurse fileset1 tree"
    echo "-a Announce subdirectories"
    echo "-d Don't report missing directories (under filespec1 but not filespec2)"
    echo "-f Don't report missing files (in filespec1 but not filespec2)"
    echo "-p Don't report Permission denied files"
    echo "-i Don't report Identical files"
}

# ------------------ SCRIPT BEGINS HERE ---------------------------------------
# Assign default control variables.
# Process - options
# Check that the command line contains at least one filespec argument.
# If there is only one argument then PWD is taken as the root of filespec1 
# and $1 is taken as the root of filespec2.  
# If there at least two arguments, $1 is taken as the root of filespec1, $2 as 
# the root of filespec2, and any additional arguments as file filters.
# Unless recursion is turned on by -r, only files in root1 and root2  will be 
# compared. Otherwise, files in all subdirectories in the root1 tree will be 
# compared to matching directories under root2. In any case, filterDif is 
# called only once and it invokes itself for any recursion.
 
recurse=      # -r turns on recurse directories
announceDirs= # -a turns on subdirectory announcement
noMissDirs=   # -d turns off reporting of missing directories

diffArg="-qsU 2"
# Options only remove components of the argument string passed to diff. The
# "U 2" cannot be removed so diffArg will never be null. 
# q = don't show details. Removed by -s option.
# s = report identicals. Removed by -i option.
# U 2 = "Universal" format with smallest context. Print context of differences. 
# This produces more text than is appropriate but otherwise diff doesn't even
# tell the file name when it prints difference details. Has no effect unless
# -s and corresponding files have differences. 

grepArg=
# grep is invoked after diff to exclude things for which diff affords no 
# filtering. grepArg is initially null and changes only in response to command 
# line options. If it is still null after processing any options, grep is not 
# invoked at all. Otherwise grep is invoked with grepArg telling it what to 
# filter out. Note that "Identical" is not a grep filter but a diff control 
# option. 
# -f Filter = "No such" for diff output "No such file or directory" Don't 
# report files that exist only in filespec1 (including implied by empty 
# filespec1).
# -p Filter = "Permission denied"

while getopts 'radsifphH' opt ; do
    case $opt in 
    s ) diffArg=${diffArg//q} ;;
    r ) recurse=1 ;;
    a ) announceDirs=1 ;;
    d ) noMissDirs=1 ;;
    f ) grepExclude 'No such'  ;;
    p ) grepExclude 'Permission denied' ;;
    i ) diffArg=${diffArg//s/} ;;
    h | H ) tellUse ; exit 0 ;;
    \? ) tellUse ; exit 1 ;;
    esac
done
shift $((OPTIND - 1))

if (( $# == 0 )) ; then
    echo "Error: At least one filespec is required"
    tellUse
    exit 1
fi

declare -i patternCnt=0

if (( $# == 1 )) ; then 
    root1="$PWD"
    root2="$1"
else
    root1="$1"
    root2="$2"
    let patternCnt=$#-2
    shift 2
    patterns=("$@")
fi

if ! [ -e "$root1" ] ; then
    echo "$root1 doesn't exist"
    exit 1
fi

if ! [ -e "$root2" ] ; then
    echo "$root2 doesn't exist"
    exit 1
fi

if (( patternCnt == 0 )) ; then
    patterns=("*")
    patternCnt=1
fi

filterDif "$root1" "$root2"