ren

android-w.song.android.widget

let OPTIND=OPTIND-1
shift $OPTIND

oldpat=$1
newpat=$2

# If -m is given, a non-existant or null newpat should be set to oldpat
if [ ${#ops[*]} -gt 0 ]; then
    case $# in
    0)
	;;
    1)
	set -- "$oldpat" "$oldpat"
	newpat=$oldpat
	$debug && print -ru2 -- "Set new pattern to: $newpat"
	;;
    *)
	if [ -z "$newpat" ]; then
	    shift 2
	    set -- "$oldpat" "$oldpat" "$@"
	    newpat=$oldpat
	    $debug && print -ru2 -- "Set new pattern to: $newpat"
	fi
	;;
    esac
fi

# Make sure input patterns that contain whitespace can be expanded properly
IFS=

origPat=$oldpat

# Generate list of filenames to act on.
case $# in
[01])
    print -u2 "$Usage\nUse -h for help."
    exit 1
    ;;
2)
    if $recurse; then
	print -r -u2 "$name: No directory names given with -r.  Use -h for help."
	exit 1
    fi
    set -- $oldpat	# Get list of all filenames that match 1st globbing pattern.
    if [[ ! -a $1 ]]; then
	$warnNoFiles && print -r -- "$name: No filenames match this pattern: $oldpat"
	exit
    fi
    ;;
*)
    shift 2
    ;;
esac

integer patSegNum=1 numPatSegs

# For old ksh
# while [[ "$oldpat" = *'[\*\?]'* ]]; do

# Example oldpat: foo*.a
# Example newpat: bar*.b

# Build list of non-pattern segments and globbing segments found in arguments.
# Note the patterns given are used to get the list of filenames to act on,
# to delimit constant segments, and to determine which parts of filenames are
# to be replaced.
# Examples given for first iteration (in the example, the only iteration)
# The || newpat  is to ensure that new pattern does not have more globbing
# segments than old pattern
while [[ "$oldpat" = *@([\*\?]|\[+([!\]])\])* ||
         "$newpat" = *@([\*\?]|\[+([!\]])\])* ]]; do
    ## Get leftmost globbing pattern in oldpat

    # Make r be oldpat with smallest left piece that includes a globbing
    # pattern removed from it
    r=${oldpat#*@([\*\?]|\[+([!\]])\])}	# r=.a
    # Make pat be oldpat with the above removed from it, leaving smallest
    # left piece that includes a globbing pattern
    pat=${oldpat%%"$r"}			# pat=foo*
    # Make l be pat with the globbing pattern removed from the right,
    # leaving a constant string
    l=${pat%@([\*\?]|\[+([!\]])\])}	# l=foo
    # Remove the constant part of pat from the left, leaving the globbing
    # pattern
    pat=${pat#"$l"}			# pat=*

    # Do the same thing for newpat, solely to provide a reliable test that
    # both oldpat & newpat contain exactly the same sequence of globbing
    # patterns.
    r=${newpat#*@([\*\?]|\[+([!\]])\])}	# r=.b
    npat=${newpat%%"$r"}		# pat=bar*
    l=${npat%@([\*\?]|\[+([!\]])\])}	# l=bar
    npat=${npat#"$l"}			# npat=*

    if [[ "$pat" != "$npat" ]]; then
	print -ru2 -- \
"$name: Old-pattern and new-pattern do not have the same sequence of globbing chars.
Pattern segment $patSegNum: Old pattern: $pat  New pattern: $npat"
	exit 1
    fi

    ## Find parts before & after pattern
    # oldpre[] stores the old constant part before the pattern,
    # so that it can be removed and replaced with the new constant part.
    oldpre[patSegNum]=${oldpat%%"$pat"*}	# oldpre[1]=foo
    # oldsuf stores the part that follows the globbing pattern,
    # so that it too can be removed.
    # After oldpre[] & oldsuf[] have been removed from a filename, what remains
    # is the part matched by the globbing pattern, which is to be retained.
    oldsuf[patSegNum]=${oldpat#*"$pat"}		# oldsuf[1]=.a
    # newpre[] stores the new constant part before the pattern,
    # so that it can be used to replace the old constant part.
    newpre[patSegNum]=${newpat%%"$pat"*}	# newpre[1]=bar
    # Get rid of processed part of patterns
    oldpat=${oldpat#${oldpre[patSegNum]}"$pat"}	# oldpat=.a
    newpat=${newpat#${newpre[patSegNum]}"$pat"}	# newpat=.b
    # Store either * or ? in pats[], depending on whether this segment matches 1
    # or any number of characters.
    [[ "$pat" = \[* ]] && pat=?
    pats[patSegNum]=$pat
    ((patSegNum+=1))
done

if [ patSegNum -eq 1 ]; then
    print -u2 "No globbing chars in pattern."
    exit 1
fi

oldpre[patSegNum]=${oldpat%%"$pat"*}	# oldpre[2]=.a
oldsuf[patSegNum]=${oldpat#*"$pat"}	# oldsuf[2]=.a
newpre[patSegNum]=${newpat%%"$pat"*}	# newpre[2]=.b

numPatSegs=patSegNum

if $debug; then
    patSegNum=1
    while [[ patSegNum -le numPatSegs ]]; do
	print -ru2 -- \
"Old prefix: <${oldpre[patSegNum]}>   Old suffix: <${oldsuf[patSegNum]}>   New prefix: <${newpre[patSegNum]}>   Pattern: <${pats[patSegNum]}>"
	((patSegNum+=1))
    done
fi

# Example filename: foox.a
# Example oldpat: foo*.a
# Example newpat: bar*.b

integer numFiles=0

# Usage: renameFile filename [dirname]
# [dirname] is a directory name to prefix filenames with when they are printed
# for informational purposes.
# Uses globals:
#     inclCt exclCt inclPats[] exclPats[] ops[]
#     numPatSegs oldpre[] oldsuf[] newpre[] pats[]
#     check warn tell verbose name
# Modifies globals: numFiles
function renameFile {
    typeset file=$1 subdir=$2
    integer patSegNum patnum
    typeset origname porigname newfile matchtext pnewfile matchsegs
    integer startseg endseg

    origname=$file	# origname=foox.a
    porigname=$subdir$file
    # Unfortunately, ksh88 does not do a good job of allowing for patterns
    # stored in variables.  Without the conditional expression being eval'ed,
    # only sh patterns are recognized.  If the expression is eval'ed, full
    # ksh expressions can be used, but then expressions that contain whitespace
    # break unless the user passed a pattern with the whitespace properly
    # quoted, which is not intuititive.  This is fixed in ksh93; full patterns
    # work without being eval'ed.
    if [ inclCt -gt 0 ]; then
	patnum=0
	while [ patnum -lt inclCt ]; do
	    [[ "$file" = ${inclPats[patnum]} ]] && break
	    ((patnum+=1))
	done
	if [ patnum -eq inclCt ]; then
	    $debug && print -ru2 -- "Skipping not-included filename '$porigname'"
	    return 1
	fi
    fi
    patnum=0
    while [ patnum -lt exclCt ]; do
	if [[ "$file" = ${exclPats[patnum]} ]]; then
	    $debug && print -ru2 -- "Skipping excluded filename '$porigname'"
	    return 1
	fi
	((patnum+=1))
    done
    # Extract matching segments from filename
    ((numFiles+=1))
    patSegNum=1
    while [[ patSegNum -le numPatSegs ]]; do
	# Remove a fixed prefix		iteration:	1		2
	file=${file#${oldpre[patSegNum]}}			# file=x.a	file=
	# Save the part of this suffix that is to be retained.  To do this, we
	# need to know what part of the suffix matched the current globbing
	# segment.  If the globbing segment is a *, this is done by removing
	# the minimum part of the suffix that matches oldsuf (since * matches
	# the longest segment possible).  If the globbing segment is ? or []
	# (the latter has already been coverted to ?), it is done by taking the
	# next character.
	if [ "${pats[patSegNum]}" == \? ]; then
	    matchtext=${file#?}
	    matchtext=${file%$matchtext}
	else
	    matchtext=${file%${oldsuf[patSegNum]}}		# matchtext=x	matchtext=
	fi
	$debug && print -ru2 -- "Matching segment $patSegNum: $matchtext"
	file=${file#$matchtext}				# file=.a	file=.a

	matchsegs[patSegNum]=$matchtext
	((patSegNum+=1))
    done

    # Paste fixed and matching segments together to form new filename.
    patSegNum=0
    newfile=
    while [[ patSegNum -le numPatSegs ]]; do
	matchtext=${matchsegs[patSegNum]}
	startseg=patSegNum
	if [ -n "${ops[startseg]}" ]; then
	    endseg=${op_end_seg[startseg]}
	    while [ patSegNum -lt endseg ]; do
		((patSegNum+=1))
		matchtext=$matchtext${matchsegs[patSegNum]}
	    done
	    if [[ "$matchtext" != +([-0-9]) ]]; then
		print -ru2 -- \
"Segment(s) $startseg - $endseg ($matchtext) of file '$porigname' do not form an integer; skipping this file."
		return 2
	    fi
	    i=$matchtext
	    let "j=${ops[startseg]}" || {
		print -ru2 -- \
"Operation failed on segment(s) $startseg - $endseg ($matchtext) of file '$file'; skipping this file."
		return 2
	    }
	    $debug && print -ru2 -- "Converted $matchtext to $j"
	    matchtext=$j
	fi
	newfile=$newfile${newpre[startseg]}$matchtext		# newfile=barx	newfile=barx.b
	((patSegNum+=1))
    done

    pnewfile=$subdir$newfile
    if $check && [ -e "$newfile" ]; then
	$warn &&
	print -ru2 -- "$name: Not renaming \"$porigname\"; destination filename \"$pnewfile\" already exists."
	return 2
    fi
    if $tell; then
	print -n -r -- "Would move: $porigname -> $pnewfile"
	$warn && [ -e "$newfile" ] && print -n -r " (destination filename already exists; would replace it)"
	print ""
    else
	if $verbose; then
	    print -n -r -- "Moving: $porigname -> $pnewfile"
	    $warn && [ -e "$newfile" ] && print -n -r -- " (replacing old destination filename \"$pnewfile\")"
	    print ""
	elif $warn && [ -e "$newfile" ]; then
	    print -r -- "$name: Note: Replacing old file \"$pnewfile\""
	fi
	mv -f -- "$origname" "$newfile"
    fi
}

if $recurse; then
    oPWD=$PWD
    find "$@" -depth -type d ! -name '*
*' -print | while read dir; do
	cd -- "$oPWD"
	if cd -- "$dir"; then
	    for file in $origPat; do
		renameFile "$file" "$dir/"
	    done
	else
	    print -ru2 -- "$name: Could not access directory '$dir' - skipped."
	fi
    done
else
    for file; do
	renameFile "$file"
    done
fi

if [ numFiles -eq 0 ]; then
    $warnNoFiles && print -ru2 -- \
    "$name: All filenames were excluded by patterns given with -p or -P."
fi