Anonymous avatar Anonymous committed 5be6007

Rewrite "git-frotz" to "git frotz"

This uses the remove-dashes target to replace "git-frotz" to "git frotz".

Signed-off-by: Junio C Hamano <gitster@pobox.com>;

Comments (0)

Files changed (142)

Documentation/install-doc-quick.sh

 export GIT_DIR
 
 test -z "$mandir" && usage
-if ! git-rev-parse --verify "$head^0" >/dev/null; then
+if ! git rev-parse --verify "$head^0" >/dev/null; then
 	echo >&2 "head: $head does not exist in the current repository"
 	usage
 fi
 GIT_INDEX_FILE=`pwd`/.quick-doc.index
 export GIT_INDEX_FILE
 rm -f "$GIT_INDEX_FILE"
-git-read-tree $head
-git-checkout-index -a -f --prefix="$mandir"/
+git read-tree $head
+git checkout-index -a -f --prefix="$mandir"/
 
 if test -n "$GZ"; then
 	cd "$mandir"
-	for i in `git-ls-tree -r --name-only $head`
+	for i in `git ls-tree -r --name-only $head`
 	do
 		gzip < $i > $i.gz && rm $i
 	done

contrib/examples/git-gc.sh

 esac
 
 test "true" != "$pack_refs" ||
-git-pack-refs --prune &&
-git-reflog expire --all &&
+git pack-refs --prune &&
+git reflog expire --all &&
 git-repack -a -d -l &&
-$no_prune git-prune &&
-git-rerere gc || exit
+$no_prune git prune &&
+git rerere gc || exit

contrib/examples/git-resolve.sh

 		"$GIT_DIR/LAST_MERGE" || exit 1
 }
 
-head=$(git-rev-parse --verify "$1"^0) &&
-merge=$(git-rev-parse --verify "$2"^0) &&
+head=$(git rev-parse --verify "$1"^0) &&
+merge=$(git rev-parse --verify "$2"^0) &&
 merge_name="$2" &&
 merge_msg="$3" || usage
 
 echo $head > "$GIT_DIR"/ORIG_HEAD
 echo $merge > "$GIT_DIR"/LAST_MERGE
 
-common=$(git-merge-base $head $merge)
+common=$(git merge-base $head $merge)
 if [ -z "$common" ]; then
 	die "Unable to find common commit between" $merge $head
 fi
 	exit 0
 	;;
 "$head")
-	echo "Updating $(git-rev-parse --short $head)..$(git-rev-parse --short $merge)"
-	git-read-tree -u -m $head $merge || exit 1
-	git-update-ref -m "resolve $merge_name: Fast forward" \
+	echo "Updating $(git rev-parse --short $head)..$(git rev-parse --short $merge)"
+	git read-tree -u -m $head $merge || exit 1
+	git update-ref -m "resolve $merge_name: Fast forward" \
 		HEAD "$merge" "$head"
-	git-diff-tree -p $head $merge | git-apply --stat
+	git diff-tree -p $head $merge | git apply --stat
 	dropheads
 	exit 0
 	;;
 # Find an optimum merge base if there are more than one candidates.
 LF='
 '
-common=$(git-merge-base -a $head $merge)
+common=$(git merge-base -a $head $merge)
 case "$common" in
 ?*"$LF"?*)
 	echo "Trying to find the optimum merge base."
 	for c in $common
 	do
 		rm -f $G
-		GIT_INDEX_FILE=$G git-read-tree -m $c $head $merge \
+		GIT_INDEX_FILE=$G git read-tree -m $c $head $merge \
 			2>/dev/null || continue
 		# Count the paths that are unmerged.
-		cnt=`GIT_INDEX_FILE=$G git-ls-files --unmerged | wc -l`
+		cnt=`GIT_INDEX_FILE=$G git ls-files --unmerged | wc -l`
 		if test $best_cnt -le 0 -o $cnt -le $best_cnt
 		then
 			best=$c
 esac
 
 echo "Trying to merge $merge into $head using $common."
-git-update-index --refresh 2>/dev/null
-git-read-tree -u -m $common $head $merge || exit 1
-result_tree=$(git-write-tree  2> /dev/null)
+git update-index --refresh 2>/dev/null
+git read-tree -u -m $common $head $merge || exit 1
+result_tree=$(git write-tree  2> /dev/null)
 if [ $? -ne 0 ]; then
 	echo "Simple merge failed, trying Automatic merge"
 	git-merge-index -o git-merge-one-file -a
 		echo $merge > "$GIT_DIR"/MERGE_HEAD
 		die "Automatic merge failed, fix up by hand"
 	fi
-	result_tree=$(git-write-tree) || exit 1
+	result_tree=$(git write-tree) || exit 1
 fi
-result_commit=$(echo "$merge_msg" | git-commit-tree $result_tree -p $head -p $merge)
+result_commit=$(echo "$merge_msg" | git commit-tree $result_tree -p $head -p $merge)
 echo "Committed merge $result_commit"
-git-update-ref -m "resolve $merge_name: In-index merge" \
+git update-ref -m "resolve $merge_name: In-index merge" \
 	HEAD "$result_commit" "$head"
-git-diff-tree -p $head $result_commit | git-apply --stat
+git diff-tree -p $head $result_commit | git apply --stat
 dropheads

contrib/remotes2config.sh

 				mv "$GIT_DIR"/remotes "$GIT_DIR"/remotes.old
 			fi ;;
 		*)
-			echo "git-config $key "$value" $regex"
-			git-config $key "$value" $regex || error=1 ;;
+			echo "git config $key "$value" $regex"
+			git config $key "$value" $regex || error=1 ;;
 		esac
 	done
 fi
     mkdir "$dotest/patch-merge-tmp-dir"
 
     # First see if the patch records the index info that we can use.
-    git-apply -z --index-info "$dotest/patch" \
+    git apply -z --index-info "$dotest/patch" \
 	>"$dotest/patch-merge-index-info" &&
     GIT_INDEX_FILE="$dotest/patch-merge-tmp-index" \
-    git-update-index -z --index-info <"$dotest/patch-merge-index-info" &&
+    git update-index -z --index-info <"$dotest/patch-merge-index-info" &&
     GIT_INDEX_FILE="$dotest/patch-merge-tmp-index" \
-    git-write-tree >"$dotest/patch-merge-base+" ||
+    git write-tree >"$dotest/patch-merge-base+" ||
     cannot_fallback "Repository lacks necessary blobs to fall back on 3-way merge."
 
     echo Using index info to reconstruct a base tree...
     if GIT_INDEX_FILE="$dotest/patch-merge-tmp-index" \
-	git-apply $binary --cached <"$dotest/patch"
+	git apply $binary --cached <"$dotest/patch"
     then
 	mv "$dotest/patch-merge-base+" "$dotest/patch-merge-base"
 	mv "$dotest/patch-merge-tmp-index" "$dotest/patch-merge-index"
     fi
 
     test -f "$dotest/patch-merge-index" &&
-    his_tree=$(GIT_INDEX_FILE="$dotest/patch-merge-index" git-write-tree) &&
+    his_tree=$(GIT_INDEX_FILE="$dotest/patch-merge-index" git write-tree) &&
     orig_tree=$(cat "$dotest/patch-merge-base") &&
     rm -fr "$dotest"/patch-merge-* || exit 1
 
     git-merge-recursive $orig_tree -- HEAD $his_tree || {
 	    if test -d "$GIT_DIR/rr-cache"
 	    then
-		git-rerere
+		git rerere
 	    fi
 	    echo Failed to merge in the changes.
 	    exit 1
 	# Start afresh.
 	mkdir -p "$dotest" || exit
 
-	git-mailsplit -d"$prec" -o"$dotest" -b -- "$@" > "$dotest/last" ||  {
+	git mailsplit -d"$prec" -o"$dotest" -b -- "$@" > "$dotest/last" ||  {
 		rm -fr "$dotest"
 		exit 1
 	}
 
 case "$resolved" in
 '')
-	files=$(git-diff-index --cached --name-only HEAD) || exit
+	files=$(git diff-index --cached --name-only HEAD) || exit
 	if [ "$files" ]; then
 	   echo "Dirty index: cannot apply patches (dirty: $files)" >&2
 	   exit 1
 then
 	if test -d "$GIT_DIR/rr-cache"
 	then
-		git-rerere clear
+		git rerere clear
 	fi
 	this=`expr "$this" + 1`
 	resume=
 	# by the user, or the user can tell us to do so by --resolved flag.
 	case "$resume" in
 	'')
-		git-mailinfo $keep $utf8 "$dotest/msg" "$dotest/patch" \
+		git mailinfo $keep $utf8 "$dotest/msg" "$dotest/patch" \
 			<"$dotest/$msgnum" >"$dotest/info" ||
 			stop_here $this
 		test -s $dotest/patch || {
 			echo "Patch is empty.  Was it split wrong?"
 			stop_here $this
 		}
-		git-stripspace < "$dotest/msg" > "$dotest/msg-clean"
+		git stripspace < "$dotest/msg" > "$dotest/msg-clean"
 		;;
 	esac
 
 		case "$resolved$interactive" in
 		tt)
 			# This is used only for interactive view option.
-			git-diff-index -p --cached HEAD >"$dotest/patch"
+			git diff-index -p --cached HEAD >"$dotest/patch"
 			;;
 		esac
 	esac
 
 	case "$resolved" in
 	'')
-		git-apply $git_apply_opt $binary --index "$dotest/patch"
+		git apply $git_apply_opt $binary --index "$dotest/patch"
 		apply_status=$?
 		;;
 	t)
 		# trust what the user has in the index file and the
 		# working tree.
 		resolved=
-		git-diff-index --quiet --cached HEAD && {
+		git diff-index --quiet --cached HEAD && {
 			echo "No changes - did you forget to use 'git add'?"
 			stop_here_user_resolve $this
 		}
-		unmerged=$(git-ls-files -u)
+		unmerged=$(git ls-files -u)
 		if test -n "$unmerged"
 		then
 			echo "You still have unmerged paths in your index"
 		then
 		    # Applying the patch to an earlier tree and merging the
 		    # result may have produced the same tree as ours.
-		    git-diff-index --quiet --cached HEAD && {
+		    git diff-index --quiet --cached HEAD && {
 			echo No changes -- Patch already applied.
 			go_next
 			continue
 		"$GIT_DIR"/hooks/pre-applypatch || stop_here $this
 	fi
 
-	tree=$(git-write-tree) &&
+	tree=$(git write-tree) &&
 	echo Wrote tree $tree &&
-	parent=$(git-rev-parse --verify HEAD) &&
-	commit=$(git-commit-tree $tree -p $parent <"$dotest/final-commit") &&
+	parent=$(git rev-parse --verify HEAD) &&
+	commit=$(git commit-tree $tree -p $parent <"$dotest/final-commit") &&
 	echo Committed: $commit &&
-	git-update-ref -m "$GIT_REFLOG_ACTION: $SUBJECT" HEAD $commit $parent ||
+	git update-ref -m "$GIT_REFLOG_ACTION: $SUBJECT" HEAD $commit $parent ||
 	stop_here $this
 
 	if test -x "$GIT_DIR"/hooks/post-applypatch
 	# Verify HEAD. If we were bisecting before this, reset to the
 	# top-of-line master first!
 	#
-	head=$(GIT_DIR="$GIT_DIR" git-symbolic-ref HEAD) ||
+	head=$(GIT_DIR="$GIT_DIR" git symbolic-ref HEAD) ||
 	die "Bad HEAD - I need a symbolic ref"
 	case "$head" in
 	refs/heads/bisect)
 		break
 		;;
 	    *)
-	        rev=$(git-rev-parse --verify "$arg^{commit}" 2>/dev/null) || {
+	        rev=$(git rev-parse --verify "$arg^{commit}" 2>/dev/null) || {
 		    test $has_double_dash -eq 1 &&
 		        die "'$arg' does not appear to be a valid revision"
 		    break
 	bisect_autostart
 	case "$#" in
 	0)
-		rev=$(git-rev-parse --verify HEAD) ;;
+		rev=$(git rev-parse --verify HEAD) ;;
 	1)
-		rev=$(git-rev-parse --verify "$1^{commit}") ;;
+		rev=$(git rev-parse --verify "$1^{commit}") ;;
 	*)
 		usage ;;
 	esac || exit
 bisect_write_bad() {
 	rev="$1"
 	echo "$rev" >"$GIT_DIR/refs/bisect/bad"
-	echo "# bad: "$(git-show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
+	echo "# bad: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
 }
 
 bisect_good() {
 	bisect_autostart
         case "$#" in
-	0)    revs=$(git-rev-parse --verify HEAD) || exit ;;
-	*)    revs=$(git-rev-parse --revs-only --no-flags "$@") &&
+	0)    revs=$(git rev-parse --verify HEAD) || exit ;;
+	*)    revs=$(git rev-parse --revs-only --no-flags "$@") &&
 		test '' != "$revs" || die "Bad rev input: $@" ;;
 	esac
 	for rev in $revs
 	do
-		rev=$(git-rev-parse --verify "$rev^{commit}") || exit
+		rev=$(git rev-parse --verify "$rev^{commit}") || exit
 		bisect_write_good "$rev"
 		echo "git-bisect good $rev" >>"$GIT_DIR/BISECT_LOG"
 
 bisect_write_good() {
 	rev="$1"
 	echo "$rev" >"$GIT_DIR/refs/bisect/good-$rev"
-	echo "# good: "$(git-show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
+	echo "# good: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
 }
 
 bisect_next_check() {
 	bisect_autostart
 	bisect_next_check good
 
-	bad=$(git-rev-parse --verify refs/bisect/bad) &&
+	bad=$(git rev-parse --verify refs/bisect/bad) &&
 	good=$(git for-each-ref --format='^%(objectname)' \
 		"refs/bisect/good-*" | tr '[\012]' ' ') &&
-	eval="git-rev-list --bisect-vars $good $bad --" &&
+	eval="git rev-list --bisect-vars $good $bad --" &&
 	eval="$eval $(cat "$GIT_DIR/BISECT_NAMES")" &&
 	eval=$(eval "$eval") &&
 	eval "$eval" || exit
 	fi
 	if [ "$bisect_rev" = "$bad" ]; then
 		echo "$bisect_rev is first bad commit"
-		git-diff-tree --pretty $bisect_rev
+		git diff-tree --pretty $bisect_rev
 		exit 0
 	fi
 
 	echo "$bisect_rev" >"$GIT_DIR/refs/heads/new-bisect"
 	git checkout -q new-bisect || exit
 	mv "$GIT_DIR/refs/heads/new-bisect" "$GIT_DIR/refs/heads/bisect" &&
-	GIT_DIR="$GIT_DIR" git-symbolic-ref HEAD refs/heads/bisect
-	git-show-branch "$bisect_rev"
+	GIT_DIR="$GIT_DIR" git symbolic-ref HEAD refs/heads/bisect
+	git show-branch "$bisect_rev"
 }
 
 bisect_visualize() {
 	   else
 	       branch=master
 	   fi ;;
-	1) git-show-ref --verify --quiet -- "refs/heads/$1" || {
+	1) git show-ref --verify --quiet -- "refs/heads/$1" || {
 	       echo >&2 "$1 does not seem to be a valid branch"
 	       exit 1
 	   }
 			;;
 		good)
 			echo "$rev" >"$GIT_DIR/refs/bisect/good-$rev"
-			echo "# good: "$(git-show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
+			echo "# good: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
 			echo "git-bisect good $rev" >>"$GIT_DIR/BISECT_LOG"
 			;;
 		bad)
 			echo "$rev" >"$GIT_DIR/refs/bisect/bad"
-			echo "# bad: "$(git-show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
+			echo "# bad: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
 			echo "git-bisect bad $rev" >>"$GIT_DIR/BISECT_LOG"
 			;;
 		*)
 require_work_tree
 
 old_name=HEAD
-old=$(git-rev-parse --verify $old_name 2>/dev/null)
-oldbranch=$(git-symbolic-ref $old_name 2>/dev/null)
+old=$(git rev-parse --verify $old_name 2>/dev/null)
+oldbranch=$(git symbolic-ref $old_name 2>/dev/null)
 new=
 new_name=
 force=
 		shift
 		[ -z "$newbranch" ] &&
 			die "git checkout: -b needs a branch name"
-		git-show-ref --verify --quiet -- "refs/heads/$newbranch" &&
+		git show-ref --verify --quiet -- "refs/heads/$newbranch" &&
 			die "git checkout: branch $newbranch already exists"
-		git-check-ref-format "heads/$newbranch" ||
+		git check-ref-format "heads/$newbranch" ||
 			die "git checkout: we do not like '$newbranch' as a branch name."
 		;;
 	"-l")
 		usage
 		;;
 	*)
-		if rev=$(git-rev-parse --verify "$arg^0" 2>/dev/null)
+		if rev=$(git rev-parse --verify "$arg^0" 2>/dev/null)
 		then
 			if [ -z "$rev" ]; then
 				echo "unknown flag $arg"
 				exit 1
 			fi
 			new_name="$arg"
-			if git-show-ref --verify --quiet -- "refs/heads/$arg"
+			if git show-ref --verify --quiet -- "refs/heads/$arg"
 			then
-				rev=$(git-rev-parse --verify "refs/heads/$arg^0")
+				rev=$(git rev-parse --verify "refs/heads/$arg^0")
 				branch="$arg"
 			fi
 			new="$rev"
-		elif rev=$(git-rev-parse --verify "$arg^{tree}" 2>/dev/null)
+		elif rev=$(git rev-parse --verify "$arg^{tree}" 2>/dev/null)
 		then
 			# checking out selected paths from a tree-ish.
 			new="$rev"
 		# from a specific tree-ish; note that this is for
 		# rescuing paths and is never meant to remove what
 		# is not in the named tree-ish.
-		git-ls-tree --full-name -r "$new" "$@" |
-		git-update-index --index-info || exit $?
+		git ls-tree --full-name -r "$new" "$@" |
+		git update-index --index-info || exit $?
 	fi
 
 	# Make sure the request is about existing paths.
-	git-ls-files --error-unmatch -- "$@" >/dev/null || exit
-	git-ls-files -- "$@" |
-	git-checkout-index -f -u --stdin
+	git ls-files --error-unmatch -- "$@" >/dev/null || exit
+	git ls-files -- "$@" |
+	git checkout-index -f -u --stdin
 	exit $?
 else
 	# Make sure we did not fall back on $arg^{tree} codepath
 	# but switching branches.
 	if test '' != "$new"
 	then
-		git-rev-parse --verify "$new^{commit}" >/dev/null 2>&1 ||
+		git rev-parse --verify "$new^{commit}" >/dev/null 2>&1 ||
 		die "Cannot switch branch to a non-commit."
 	fi
 fi
 
 if [ "$force" ]
 then
-    git-read-tree $v --reset -u $new
+    git read-tree $v --reset -u $new
 else
-    git-update-index --refresh >/dev/null
-    merge_error=$(git-read-tree -m -u --exclude-per-directory=.gitignore $old $new 2>&1) || (
+    git update-index --refresh >/dev/null
+    merge_error=$(git read-tree -m -u --exclude-per-directory=.gitignore $old $new 2>&1) || (
 	case "$merge" in
 	'')
 		echo >&2 "$merge_error"
 #
 if [ "$?" -eq 0 ]; then
 	if [ "$newbranch" ]; then
-		git-branch $track $newbranch_log "$newbranch" "$new_name" || exit
+		git branch $track $newbranch_log "$newbranch" "$new_name" || exit
 		branch="$newbranch"
 	fi
 	if test -n "$branch"
 	then
-		GIT_DIR="$GIT_DIR" git-symbolic-ref -m "checkout: moving to $branch" HEAD "refs/heads/$branch"
+		GIT_DIR="$GIT_DIR" git symbolic-ref -m "checkout: moving to $branch" HEAD "refs/heads/$branch"
 		if test -n "$quiet"
 		then
 			true	# nothing
 		fi
 	elif test -n "$detached"
 	then
-		git-update-ref --no-deref -m "checkout: moving to $arg" HEAD "$detached" ||
+		git update-ref --no-deref -m "checkout: moving to $arg" HEAD "$detached" ||
 			die "Cannot detach HEAD"
 		if test -n "$detach_warn"
 		then
 ignored=
 ignoredonly=
 cleandir=
-disabled="`git-config --bool clean.requireForce`"
+disabled="`git config --bool clean.requireForce`"
 rmf="rm -f --"
 rmrf="rm -rf --"
 rm_refuse="echo Not removing"
 	fi
 fi
 
-git-ls-files --others --directory $excl ${excl_info:+"$excl_info"} -- "$@" |
+git ls-files --others --directory $excl ${excl_info:+"$excl_info"} -- "$@" |
 while read -r file; do
 	if [ -d "$file" -a ! -L "$file" ]; then
 		if [ -z "$cleandir" ]; then
 	clone_tmp="$GIT_DIR/clone-tmp" &&
 	mkdir -p "$clone_tmp" || exit 1
 	if [ -n "$GIT_CURL_FTP_NO_EPSV" -o \
-		"`git-config --bool http.noEPSV`" = true ]; then
+		"`git config --bool http.noEPSV`" = true ]; then
 		curl_extra_args="${curl_extra_args} --disable-epsv"
 	fi
 	http_fetch "$1/info/refs" "$clone_tmp/refs" ||
 		*/*)
 		    die "'$2' is not suitable for an origin name"
 		esac
-		git-check-ref-format "heads/$2" ||
+		git check-ref-format "heads/$2" ||
 		    die "'$2' is not suitable for a branch name"
 		test -z "$origin_override" ||
 		    die "Do not give more than one --origin options."
 	GIT_DIR="$D" ;;
 *)
 	GIT_DIR="$D/.git" ;;
-esac && export GIT_DIR && git-init $quiet ${template+"$template"} || usage
+esac && export GIT_DIR && git init $quiet ${template+"$template"} || usage
 
 if test -n "$reference"
 then
 		*)
 			continue ;;
 		esac
-		git-update-ref -m "clone: from $repo" "$destname" "$sha1" ""
+		git update-ref -m "clone: from $repo" "$destname" "$sha1" ""
 	done < "$GIT_DIR/CLONE_HEAD"
 fi
 
 	)
 
 	# Upstream URL
-	git-config remote."$origin".url "$repo" &&
+	git config remote."$origin".url "$repo" &&
 
 	# Set up the mappings to track the remote branches.
-	git-config remote."$origin".fetch \
+	git config remote."$origin".fetch \
 		"+refs/heads/*:$remote_top/*" '^$' &&
 
 	# Write out remote.$origin config, and update our "$head_points_at".
 	case "$head_points_at" in
 	?*)
 		# Local default branch
-		git-symbolic-ref HEAD "refs/heads/$head_points_at" &&
+		git symbolic-ref HEAD "refs/heads/$head_points_at" &&
 
 		# Tracking branch for the primary branch at the remote.
-		git-update-ref HEAD "$head_sha1" &&
+		git update-ref HEAD "$head_sha1" &&
 
 		rm -f "refs/remotes/$origin/HEAD"
-		git-symbolic-ref "refs/remotes/$origin/HEAD" \
+		git symbolic-ref "refs/remotes/$origin/HEAD" \
 			"refs/remotes/$origin/$head_points_at" &&
 
-		git-config branch."$head_points_at".remote "$origin" &&
-		git-config branch."$head_points_at".merge "refs/heads/$head_points_at"
+		git config branch."$head_points_at".remote "$origin" &&
+		git config branch."$head_points_at".merge "refs/heads/$head_points_at"
 		;;
 	'')
 		# Source had detached HEAD pointing nowhere
-		git-update-ref --no-deref HEAD "$head_sha1" &&
+		git update-ref --no-deref HEAD "$head_sha1" &&
 		rm -f "refs/remotes/$origin/HEAD"
 		;;
 	esac
 	case "$no_checkout" in
 	'')
 		test "z$quiet" = z -a "z$no_progress" = z && v=-v || v=
-		git-read-tree -m -u $v HEAD HEAD
+		git read-tree -m -u $v HEAD HEAD
 	esac
 fi
 rm -f "$GIT_DIR/CLONE_HEAD" "$GIT_DIR/REMOTE_HEAD"
 . git-sh-setup
 require_work_tree
 
-git-rev-parse --verify HEAD >/dev/null 2>&1 || initial_commit=t
+git rev-parse --verify HEAD >/dev/null 2>&1 || initial_commit=t
 
 case "$0" in
 *status)
 	t) color= ;;
 	*) color=--nocolor ;;
 	esac
-	git-runstatus ${color} \
+	git runstatus ${color} \
 		${verbose:+--verbose} \
 		${amend:+--amend} \
 		${untracked_files:+--untracked}
 		cd_to_toplevel &&
 		GIT_INDEX_FILE="$NEXT_INDEX" &&
 		export GIT_INDEX_FILE &&
-		git-diff-files --name-only -z |
-		git-update-index --remove -z --stdin
+		git diff-files --name-only -z |
+		git update-index --remove -z --stdin
 	) || exit
 	;;
 ,t)
 	save_index &&
-	git-ls-files --error-unmatch -- "$@" >/dev/null || exit
+	git ls-files --error-unmatch -- "$@" >/dev/null || exit
 
-	git-diff-files --name-only -z -- "$@"  |
+	git diff-files --name-only -z -- "$@"  |
 	(
 		cd_to_toplevel &&
 		GIT_INDEX_FILE="$NEXT_INDEX" &&
 		export GIT_INDEX_FILE &&
-		git-update-index --remove -z --stdin
+		git update-index --remove -z --stdin
 	) || exit
 	;;
 ,)
 			refuse_partial "Cannot do a partial commit during a merge."
 		fi
 		TMP_INDEX="$GIT_DIR/tmp-index$$"
-		commit_only=`git-ls-files --error-unmatch -- "$@"` || exit
+		commit_only=`git ls-files --error-unmatch -- "$@"` || exit
 
 		# Build a temporary index and update the real index
 		# the same way.
 		if test -z "$initial_commit"
 		then
 			GIT_INDEX_FILE="$THIS_INDEX" \
-			git-read-tree --index-output="$TMP_INDEX" -i -m HEAD
+			git read-tree --index-output="$TMP_INDEX" -i -m HEAD
 		else
 			rm -f "$TMP_INDEX"
 		fi || exit
 
 		printf '%s\n' "$commit_only" |
 		GIT_INDEX_FILE="$TMP_INDEX" \
-		git-update-index --add --remove --stdin &&
+		git update-index --add --remove --stdin &&
 
 		save_index &&
 		printf '%s\n' "$commit_only" |
 		(
 			GIT_INDEX_FILE="$NEXT_INDEX"
 			export GIT_INDEX_FILE
-			git-update-index --remove --stdin
+			git update-index --remove --stdin
 		) || exit
 		;;
 	esac
 t)
 	# This will silently fail in a read-only repository, which is
 	# what we want.
-	GIT_INDEX_FILE="$USE_INDEX" git-update-index -q --unmerged --refresh
+	GIT_INDEX_FILE="$USE_INDEX" git update-index -q --unmerged --refresh
 	run_status
 	exit $?
 	;;
 '')
-	GIT_INDEX_FILE="$USE_INDEX" git-update-index -q --refresh || exit
+	GIT_INDEX_FILE="$USE_INDEX" git update-index -q --refresh || exit
 	;;
 esac
 
 elif test -f "$GIT_DIR/SQUASH_MSG"
 then
 	cat "$GIT_DIR/SQUASH_MSG"
-fi | git-stripspace >"$GIT_DIR"/COMMIT_EDITMSG
+fi | git stripspace >"$GIT_DIR"/COMMIT_EDITMSG
 
 case "$signoff" in
 t)
 		PARENTS="-p HEAD "`sed -e 's/^/-p /' "$GIT_DIR/MERGE_HEAD"`
 	elif test -n "$amend"; then
 		rloga='commit (amend)'
-		PARENTS=$(git-cat-file commit HEAD |
+		PARENTS=$(git cat-file commit HEAD |
 			sed -n -e '/^$/q' -e 's/^parent /-p /p')
 	fi
-	current="$(git-rev-parse --verify HEAD)"
+	current="$(git rev-parse --verify HEAD)"
 else
-	if [ -z "$(git-ls-files)" ]; then
+	if [ -z "$(git ls-files)" ]; then
 		echo >&2 'nothing to commit (use "git add file1 file2" to include for commit)'
 		exit 1
 	fi
 else
     cat "$GIT_DIR"/COMMIT_EDITMSG
 fi |
-git-stripspace >"$GIT_DIR"/COMMIT_MSG
+git stripspace >"$GIT_DIR"/COMMIT_MSG
 
 if cnt=`grep -v -i '^Signed-off-by' "$GIT_DIR"/COMMIT_MSG |
-	git-stripspace |
+	git stripspace |
 	wc -l` &&
    test 0 -lt $cnt
 then
 	if test -z "$TMP_INDEX"
 	then
-		tree=$(GIT_INDEX_FILE="$USE_INDEX" git-write-tree)
+		tree=$(GIT_INDEX_FILE="$USE_INDEX" git write-tree)
 	else
-		tree=$(GIT_INDEX_FILE="$TMP_INDEX" git-write-tree) &&
+		tree=$(GIT_INDEX_FILE="$TMP_INDEX" git write-tree) &&
 		rm -f "$TMP_INDEX"
 	fi &&
-	commit=$(cat "$GIT_DIR"/COMMIT_MSG | git-commit-tree $tree $PARENTS) &&
+	commit=$(cat "$GIT_DIR"/COMMIT_MSG | git commit-tree $tree $PARENTS) &&
 	rlogm=$(sed -e 1q "$GIT_DIR"/COMMIT_MSG) &&
-	git-update-ref -m "$GIT_REFLOG_ACTION: $rlogm" HEAD $commit "$current" &&
+	git update-ref -m "$GIT_REFLOG_ACTION: $rlogm" HEAD $commit "$current" &&
 	rm -f -- "$GIT_DIR/MERGE_HEAD" "$GIT_DIR/MERGE_MSG" &&
 	if test -f "$NEXT_INDEX"
 	then
 
 if test -d "$GIT_DIR/rr-cache"
 then
-	git-rerere
+	git rerere
 fi
 
 if test "$ret" = 0
 	fi
 	if test -z "$quiet"
 	then
-		commit=`git-diff-tree --always --shortstat --pretty="format:%h: %s"\
+		commit=`git diff-tree --always --shortstat --pretty="format:%h: %s"\
 		       --summary --root HEAD --`
 		echo "Created${initial_commit:+ initial} commit $commit"
 	fi
 	test -n "$verbose" && flags="$flags$LF-v"
 	test -n "$force$single_force" && flags="$flags$LF-f"
 	GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION" \
-		git-fetch--tool $flags append-fetch-head "$@"
+		git fetch--tool $flags append-fetch-head "$@"
 }
 
 # updating the current HEAD with git-fetch in a bare
 # repository is always fine.
 if test -z "$update_head_ok" && test $(is_bare_repository) = false
 then
-	orig_head=$(git-rev-parse --verify HEAD 2>/dev/null)
+	orig_head=$(git rev-parse --verify HEAD 2>/dev/null)
 fi
 
 # Allow --notags from remote.$1.tagopt
 case "$tags$no_tags" in
 '')
-	case "$(git-config --get "remote.$1.tagopt")" in
+	case "$(git config --get "remote.$1.tagopt")" in
 	--no-tags)
 		no_tags=t ;;
 	esac
 then
 	taglist=`IFS='	' &&
 		  echo "$ls_remote_result" |
-		  git-show-ref --exclude-existing=refs/tags/ |
+		  git show-ref --exclude-existing=refs/tags/ |
 	          while read sha1 name
 		  do
 			echo ".${name}:${name}"
 
 fetch_all_at_once () {
 
-  eval=$(echo "$1" | git-fetch--tool parse-reflist "-")
+  eval=$(echo "$1" | git fetch--tool parse-reflist "-")
   eval "$eval"
 
     ( : subshell because we muck with IFS
       IFS=" 	$LF"
       (
 	if test "$remote" = . ; then
-	    git-show-ref $rref || echo failed "$remote"
+	    git show-ref $rref || echo failed "$remote"
 	elif test -f "$remote" ; then
 	    test -n "$shallow_depth" &&
 		die "shallow clone with bundle is not supported"
-	    git-bundle unbundle "$remote" $rref ||
+	    git bundle unbundle "$remote" $rref ||
 	    echo failed "$remote"
 	else
 		if	test -d "$remote" &&
 			# connected to our repository's tips, in which
 			# case we do not have to do any fetch.
 			theirs=$(echo "$ls_remote_result" | \
-				git-fetch--tool -s pick-rref "$rref" "-") &&
+				git fetch--tool -s pick-rref "$rref" "-") &&
 
 			# This will barf when $theirs reach an object that
 			# we do not have in our repository.  Otherwise,
 			# we already have everything the fetch would bring in.
-			git-rev-list --objects $theirs --not --all \
+			git rev-list --objects $theirs --not --all \
 				>/dev/null 2>/dev/null
 		then
 			echo "$ls_remote_result" | \
-				git-fetch--tool pick-rref "$rref" "-"
+				git fetch--tool pick-rref "$rref" "-"
 		else
 			flags=
 			case $verbose in
 	test -n "$verbose" && flags="$flags -v"
 	test -n "$force" && flags="$flags -f"
 	GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION" \
-		git-fetch--tool $flags native-store \
+		git fetch--tool $flags native-store \
 			"$remote" "$remote_nick" "$refs"
       )
     ) || exit
 	      curl_extra_args="-k"
 	  fi
 	  if [ -n "$GIT_CURL_FTP_NO_EPSV" -o \
-		"`git-config --bool http.noEPSV`" = true ]; then
+		"`git config --bool http.noEPSV`" = true ]; then
 	      noepsv_opt="--disable-epsv"
 	  fi
 
 	  # Find $remote_name from ls-remote output.
 	  head=$(echo "$ls_remote_result" | \
-		git-fetch--tool -s pick-rref "$remote_name" "-")
+		git fetch--tool -s pick-rref "$remote_name" "-")
 	  expr "z$head" : "z$_x40\$" >/dev/null ||
 		die "No such ref $remote_name at $remote"
 	  echo >&2 "Fetching $remote_name from $remote using $proto"
 		die "shallow clone with rsync not supported"
 	  TMP_HEAD="$GIT_DIR/TMP_HEAD"
 	  rsync -L -q "$remote/$remote_name" "$TMP_HEAD" || exit 1
-	  head=$(git-rev-parse --verify TMP_HEAD)
+	  head=$(git rev-parse --verify TMP_HEAD)
 	  rm -f "$TMP_HEAD"
 	  case "$quiet" in '') v=-v ;; *) v= ;; esac
 	  test "$rsync_slurped_objects" || {
 		# using local tracking branch.
 		taglist=$(IFS='	' &&
 		echo "$ls_remote_result" |
-		git-show-ref --exclude-existing=refs/tags/ |
+		git show-ref --exclude-existing=refs/tags/ |
 		while read sha1 name
 		do
-			git-cat-file -t "$sha1" >/dev/null 2>&1 || continue
+			git cat-file -t "$sha1" >/dev/null 2>&1 || continue
 			echo >&2 "Auto-following $name"
 			echo ".${name}:${name}"
 		done)
 '')
 	;;
 ?*)
-	curr_head=$(git-rev-parse --verify HEAD 2>/dev/null)
+	curr_head=$(git rev-parse --verify HEAD 2>/dev/null)
 	if test "$curr_head" != "$orig_head"
 	then
-	    git-update-ref \
+	    git update-ref \
 			-m "$GIT_REFLOG_ACTION: Undoing incorrectly fetched HEAD." \
 			HEAD "$orig_head"
 		die "Cannot fetch into the current branch."

git-filter-branch.sh

 #	This is the filter for rewriting the commit's parent list.
 #	It will receive the parent string on stdin and shall output
 #	the new parent string on stdout. The parent string is in
-#	format accepted by `git-commit-tree`: empty for initial
+#	format accepted by `git commit-tree`: empty for initial
 #	commit, "-p parent" for a normal commit and "-p parent1
 #	-p parent2 -p parent3 ..." for a merge commit.
 #
 #
 # --commit-filter COMMAND:: The filter for performing the commit
 #	If this filter is passed, it will be called instead of the
-#	`git-commit-tree` command, with those arguments:
+#	`git commit-tree` command, with those arguments:
 #
 #		TREE_ID [-p PARENT_COMMIT_ID]...
 #
 #
 # A significantly faster version:
 #
-#	git-filter-branch --index-filter 'git-update-index --remove filename' newbranch
+#	git-filter-branch --index-filter 'git update-index --remove filename' newbranch
 #
 # Now, you will get the rewritten history saved in the branch 'newbranch'
 # (your current branch is left untouched).
 #
 # To remove commits authored by "Darl McBribe" from the history:
 #
-#	git-filter-branch --commit-filter 'if [ "$GIT_AUTHOR_NAME" = "Darl McBribe" ]; then shift; while [ -n "$1" ]; do shift; echo "$1"; shift; done; else git-commit-tree "$@"; fi' newbranch
+#	git-filter-branch --commit-filter 'if [ "$GIT_AUTHOR_NAME" = "Darl McBribe" ]; then shift; while [ -n "$1" ]; do shift; echo "$1"; shift; done; else git commit-tree "$@"; fi' newbranch
 #
 # (the shift magic first throws away the tree id and then the -p
 # parameters). Note that this handles merges properly! In case Darl
 # To move the whole tree into a subdirectory, or remove it from there:
 #
 # git-filter-branch --index-filter \
-#	'git-ls-files -s | sed "s-\t-&newsubdir/-" |
+#	'git ls-files -s | sed "s-\t-&newsubdir/-" |
 #		GIT_INDEX_FILE=$GIT_INDEX_FILE.new \
-#			git-update-index --index-info &&
+#			git update-index --index-info &&
 #	 mv $GIT_INDEX_FILE.new $GIT_INDEX_FILE' directorymoved
 
 # Testsuite: TODO
 filter_index=
 filter_parent=
 filter_msg=cat
-filter_commit='git-commit-tree "$@"'
+filter_commit='git commit-tree "$@"'
 filter_tag_name=
 filter_subdir=
 while case "$#" in 0) usage;; esac
 dstbranch="$1"
 shift
 test -n "$dstbranch" || die "missing branch name"
-git-show-ref "refs/heads/$dstbranch" 2> /dev/null &&
+git show-ref "refs/heads/$dstbranch" 2> /dev/null &&
 	die "branch $dstbranch already exists"
 
 test ! -e "$tempdir" || die "$tempdir already exists, please remove it"
 export GIT_DIR GIT_WORK_TREE=.
 
 export GIT_INDEX_FILE="$(pwd)/../index"
-git-read-tree # seed the index file
+git read-tree # seed the index file
 
 ret=0
 
 
 case "$filter_subdir" in
 "")
-	git-rev-list --reverse --topo-order --default HEAD \
+	git rev-list --reverse --topo-order --default HEAD \
 		--parents "$@"
 	;;
 *)
-	git-rev-list --reverse --topo-order --default HEAD \
+	git rev-list --reverse --topo-order --default HEAD \
 		--parents --full-history "$@" -- "$filter_subdir"
 esac > ../revs
 commits=$(cat ../revs | wc -l | tr -d " ")
 
 	case "$filter_subdir" in
 	"")
-		git-read-tree -i -m $commit
+		git read-tree -i -m $commit
 		;;
 	*)
-		git-read-tree -i -m $commit:"$filter_subdir"
+		git read-tree -i -m $commit:"$filter_subdir"
 	esac
 
 	export GIT_COMMIT=$commit
-	git-cat-file commit "$commit" >../commit
+	git cat-file commit "$commit" >../commit
 
 	eval "$(set_ident AUTHOR <../commit)"
 	eval "$(set_ident COMMITTER <../commit)"
 	eval "$filter_env" < /dev/null
 
 	if [ "$filter_tree" ]; then
-		git-checkout-index -f -u -a
+		git checkout-index -f -u -a
 		# files that $commit removed are now still in the working tree;
 		# remove them, else they would be added again
-		git-ls-files -z --others | xargs -0 rm -f
+		git ls-files -z --others | xargs -0 rm -f
 		eval "$filter_tree" < /dev/null
-		git-diff-index -r $commit | cut -f 2- | tr '\n' '\0' | \
-			xargs -0 git-update-index --add --replace --remove
-		git-ls-files -z --others | \
-			xargs -0 git-update-index --add --replace --remove
+		git diff-index -r $commit | cut -f 2- | tr '\n' '\0' | \
+			xargs -0 git update-index --add --replace --remove
+		git ls-files -z --others | \
+			xargs -0 git update-index --add --replace --remove
 	fi
 
 	eval "$filter_index" < /dev/null
 
 	sed -e '1,/^$/d' <../commit | \
 		eval "$filter_msg" | \
-		sh -c "$filter_commit" "git-commit-tree" $(git-write-tree) $parentstr | \
+		sh -c "$filter_commit" "git commit-tree" $(git write-tree) $parentstr | \
 		tee ../map/$commit
 done <../revs
 
 	echo Nothing rewritten
 	;;
 *)
-	git-update-ref refs/heads/"$dstbranch" $target_head
+	git update-ref refs/heads/"$dstbranch" $target_head
 	if [ $(cat ../map/$src_head | wc -l) -gt 1 ]; then
 		echo "WARNING: Your commit filter caused the head commit to expand to several rewritten commits. Only the first such commit was recorded as the current $dstbranch head but you will need to resolve the situation now (probably by manually merging the other commits). These are all the commits:" >&2
 		sed 's/^/	/' ../map/$src_head >&2
 esac
 
 if [ "$filter_tag_name" ]; then
-	git-for-each-ref --format='%(objectname) %(objecttype) %(refname)' refs/tags |
+	git for-each-ref --format='%(objectname) %(objecttype) %(refname)' refs/tags |
 	while read sha1 type ref; do
 		ref="${ref#refs/tags/}"
 		# XXX: Rewrite tagged trees as well?
 		if [ "$type" = "tag" ]; then
 			# Dereference to a commit
 			sha1t="$sha1"
-			sha1="$(git-rev-parse "$sha1"^{commit} 2>/dev/null)" || continue
+			sha1="$(git rev-parse "$sha1"^{commit} 2>/dev/null)" || continue
 		fi
 
 		[ -f "../map/$sha1" ] || continue
 			warn "unreferencing tag object $sha1t"
 		fi
 
-		git-update-ref "refs/tags/$new_ref" "$new_sha1"
+		git update-ref "refs/tags/$new_ref" "$new_sha1"
 	done
 fi
 

git-lost-found.sh

 do
 	case "$dangling" in
 	dangling)
-		if git-rev-parse --verify "$sha1^0" >/dev/null 2>/dev/null
+		if git rev-parse --verify "$sha1^0" >/dev/null 2>/dev/null
 		then
 			dir="$laf/commit"
-			git-show-branch "$sha1"
+			git show-branch "$sha1"
 		else
 			dir="$laf/other"
 		fi
             curl_extra_args="-k"
         fi
 	if [ -n "$GIT_CURL_FTP_NO_EPSV" -o \
-		"`git-config --bool http.noEPSV`" = true ]; then
+		"`git config --bool http.noEPSV`" = true ]; then
 		curl_extra_args="${curl_extra_args} --disable-epsv"
 	fi
 	curl -nsf $curl_extra_args --header "Pragma: no-cache" "$peek_repo/info/refs" ||

git-merge-octopus.sh

 # MRT is the current "merge result tree"
 
 MRC=$head MSG= PARENT="-p $head"
-MRT=$(git-write-tree)
+MRT=$(git write-tree)
 CNT=1 ;# counting our head
 NON_FF_MERGE=0
 OCTOPUS_FAILURE=0
 		exit 2
 	esac
 
-	common=$(git-merge-base --all $MRC $SHA1) ||
+	common=$(git merge-base --all $MRC $SHA1) ||
 		die "Unable to find common commit with $SHA1"
 
 	case "$LF$common$LF" in
 		# We still need to count this as part of the parent set.
 
 		echo "Fast forwarding to: $SHA1"
-		git-read-tree -u -m $head $SHA1 || exit
-		MRC=$SHA1 MRT=$(git-write-tree)
+		git read-tree -u -m $head $SHA1 || exit
+		MRC=$SHA1 MRT=$(git write-tree)
 		continue
 	fi
 
 	NON_FF_MERGE=1
 
 	echo "Trying simple merge with $SHA1"
-	git-read-tree -u -m --aggressive  $common $MRT $SHA1 || exit 2
-	next=$(git-write-tree 2>/dev/null)
+	git read-tree -u -m --aggressive  $common $MRT $SHA1 || exit 2
+	next=$(git write-tree 2>/dev/null)
 	if test $? -ne 0
 	then
 		echo "Simple merge did not work, trying automatic merge."
 		git-merge-index -o git-merge-one-file -a ||
 		OCTOPUS_FAILURE=1
-		next=$(git-write-tree 2>/dev/null)
+		next=$(git write-tree 2>/dev/null)
 	fi
 
 	# We have merged the other branch successfully.  Ideally

git-merge-one-file.sh

 #   $7 - file in branch2 mode (or empty)
 #
 # Handle some trivial cases.. The _really_ trivial cases have
-# been handled already by git-read-tree, but that one doesn't
+# been handled already by git read-tree, but that one doesn't
 # do any merges that might change the tree layout.
 
 case "${1:-.}${2:-.}${3:-.}" in
 		rm -f -- "$4" &&
 		rmdir -p "$(expr "z$4" : 'z\(.*\)/')" 2>/dev/null || :
 	fi &&
-		exec git-update-index --remove -- "$4"
+		exec git update-index --remove -- "$4"
 	;;
 
 #
 		echo "ERROR: untracked $4 is overwritten by the merge."
 		exit 1
 	}
-	git-update-index --add --cacheinfo "$6$7" "$2$3" "$4" &&
-		exec git-checkout-index -u -f -- "$4"
+	git update-index --add --cacheinfo "$6$7" "$2$3" "$4" &&
+		exec git checkout-index -u -f -- "$4"
 	;;
 
 #
 		exit 1
 	fi
 	echo "Adding $4"
-	git-update-index --add --cacheinfo "$6" "$2" "$4" &&
-		exec git-checkout-index -u -f -- "$4"
+	git update-index --add --cacheinfo "$6" "$2" "$4" &&
+		exec git checkout-index -u -f -- "$4"
 	;;
 
 #
 	case "$1" in
 	'')
 		echo "Added $4 in both, but differently."
-		# This extracts OUR file in $orig, and uses git-apply to
+		# This extracts OUR file in $orig, and uses git apply to
 		# remove lines that are unique to ours.
 		orig=`git-unpack-file $2`
 		sz0=`wc -c <"$orig"`
-		diff -u -La/$orig -Lb/$orig $orig $src2 | git-apply --no-add
+		diff -u -La/$orig -Lb/$orig $orig $src2 | git apply --no-add
 		sz1=`wc -c <"$orig"`
 
 		# If we do not have enough common material, it is not
 	# Be careful for funny filename such as "-L" in "$4", which
 	# would confuse "merge" greatly.
 	src1=`git-unpack-file $2`
-	git-merge-file "$src1" "$orig" "$src2"
+	git merge-file "$src1" "$orig" "$src2"
 	ret=$?
 
 	# Create the working tree file, using "our tree" version from the
 	# index, and then store the result of the merge.
-	git-checkout-index -f --stage=2 -- "$4" && cat "$src1" >"$4"
+	git checkout-index -f --stage=2 -- "$4" && cat "$src1" >"$4"
 	rm -f -- "$orig" "$src1" "$src2"
 
 	if [ "$6" != "$7" ]; then
 		echo "ERROR: Merge conflict in $4"
 		exit 1
 	fi
-	exec git-update-index -- "$4"
+	exec git update-index -- "$4"
 	;;
 
 *)

git-merge-ours.sh

 # because the current index is what we will be committing as the
 # merge result.
 
-git-diff-index --quiet --cached HEAD || exit 2
+git diff-index --quiet --cached HEAD || exit 2
 
 exit 0

git-merge-resolve.sh

 	exit 2
 fi
 
-git-update-index --refresh 2>/dev/null
-git-read-tree -u -m --aggressive $bases $head $remotes || exit 2
+git update-index --refresh 2>/dev/null
+git read-tree -u -m --aggressive $bases $head $remotes || exit 2
 echo "Trying simple merge."
-if result_tree=$(git-write-tree  2>/dev/null)
+if result_tree=$(git write-tree  2>/dev/null)
 then
 	exit 0
 else

git-merge-stupid.sh

 	for c in $bases
 	do
 		rm -f $G
-		GIT_INDEX_FILE=$G git-read-tree -m $c $head $remotes \
+		GIT_INDEX_FILE=$G git read-tree -m $c $head $remotes \
 			 2>/dev/null ||	continue
 		# Count the paths that are unmerged.
-		cnt=`GIT_INDEX_FILE=$G git-ls-files --unmerged | wc -l`
+		cnt=`GIT_INDEX_FILE=$G git ls-files --unmerged | wc -l`
 		if test $best_cnt -le 0 -o $cnt -le $best_cnt
 		then
 			best=$c
 	;;
 esac
 
-git-update-index --refresh 2>/dev/null
-git-read-tree -u -m $common $head $remotes || exit 2
+git update-index --refresh 2>/dev/null
+git read-tree -u -m $common $head $remotes || exit 2
 echo "Trying simple merge."
-if result_tree=$(git-write-tree  2>/dev/null)
+if result_tree=$(git write-tree  2>/dev/null)
 then
 	exit 0
 else
 
 savestate() {
 	# Stash away any local modifications.
-	git-diff-index -z --name-only $head |
+	git diff-index -z --name-only $head |
 	cpio -0 -o >"$GIT_DIR/MERGE_SAVE"
 }
 
 	then
 		git reset --hard $head >/dev/null
 		cpio -iuv <"$GIT_DIR/MERGE_SAVE"
-		git-update-index --refresh >/dev/null
+		git update-index --refresh >/dev/null
 	fi
 }
 
 squash_message () {
 	echo Squashed commit of the following:
 	echo
-	git-log --no-merges ^"$head" $remote
+	git log --no-merges ^"$head" $remote
 }
 
 finish () {
 			echo "No merge message -- not updating HEAD"
 			;;
 		*)
-			git-update-ref -m "$rlogm" HEAD "$1" "$head" || exit 1
+			git update-ref -m "$rlogm" HEAD "$1" "$head" || exit 1
 			;;
 		esac
 		;;
 		if test "$show_diffstat" = t
 		then
 			# We want color (if set), but no pager
-			GIT_PAGER='' git-diff --stat --summary -M "$head" "$1"
+			GIT_PAGER='' git diff --stat --summary -M "$head" "$1"
 		fi
 		;;
 	esac
 
 merge_name () {
 	remote="$1"
-	rh=$(git-rev-parse --verify "$remote^0" 2>/dev/null) || return
-	bh=$(git-show-ref -s --verify "refs/heads/$remote" 2>/dev/null)
+	rh=$(git rev-parse --verify "$remote^0" 2>/dev/null) || return
+	bh=$(git show-ref -s --verify "refs/heads/$remote" 2>/dev/null)
 	if test "$rh" = "$bh"
 	then
 		echo "$rh		branch '$remote' of ."
 	elif truname=$(expr "$remote" : '\(.*\)~[1-9][0-9]*$') &&
-		git-show-ref -q --verify "refs/heads/$truname" 2>/dev/null
+		git show-ref -q --verify "refs/heads/$truname" 2>/dev/null
 	then
 		echo "$rh		branch '$truname' (early part) of ."
 	elif test "$remote" = "FETCH_HEAD" -a -r "$GIT_DIR/FETCH_HEAD"
 done
 
 if test -z "$show_diffstat"; then
-    test "$(git-config --bool merge.diffstat)" = false && show_diffstat=false
+    test "$(git config --bool merge.diffstat)" = false && show_diffstat=false
     test -z "$show_diffstat" && show_diffstat=t
 fi
 
 # have "-m" so it is an additional safety measure to check for it.
 
 if test -z "$have_message" &&
-	second_token=$(git-rev-parse --verify "$2^0" 2>/dev/null) &&
-	head_commit=$(git-rev-parse --verify "HEAD" 2>/dev/null) &&
+	second_token=$(git rev-parse --verify "$2^0" 2>/dev/null) &&
+	head_commit=$(git rev-parse --verify "HEAD" 2>/dev/null) &&
 	test "$second_token" = "$head_commit"
 then
 	merge_msg="$1"
 	shift
 	head_arg="$1"
 	shift
-elif ! git-rev-parse --verify HEAD >/dev/null 2>&1
+elif ! git rev-parse --verify HEAD >/dev/null 2>&1
 then
 	# If the merged head is a valid one there is no reason to
 	# forbid "git merge" into a branch yet to be born.  We do
 	rh=$(git rev-parse --verify "$1^0") ||
 		die "$1 - not something we can merge"
 
-	git-update-ref -m "initial pull" HEAD "$rh" "" &&
-	git-read-tree --reset -u HEAD
+	git update-ref -m "initial pull" HEAD "$rh" "" &&
+	git read-tree --reset -u HEAD
 	exit
 
 else
 	merge_name=$(for remote
 		do
 			merge_name "$remote"
-		done | git-fmt-merge-msg
+		done | git fmt-merge-msg
 	)
 	merge_msg="${merge_msg:+$merge_msg$LF$LF}$merge_name"
 fi
-head=$(git-rev-parse --verify "$head_arg"^0) || usage
+head=$(git rev-parse --verify "$head_arg"^0) || usage
 
 # All the rest are remote heads
 test "$#" = 0 && usage ;# we need at least one remote head.
 remoteheads=
 for remote
 do
-	remotehead=$(git-rev-parse --verify "$remote"^0 2>/dev/null) ||
+	remotehead=$(git rev-parse --verify "$remote"^0 2>/dev/null) ||
 	    die "$remote - not something we can merge"
 	remoteheads="${remoteheads}$remotehead "
 	eval GITHEAD_$remotehead='"$remote"'
 '')
 	case "$#" in
 	1)
-		var="`git-config --get pull.twohead`"
+		var="`git config --get pull.twohead`"
 		if test -n "$var"
 		then
 			use_strategies="$var"
 			use_strategies="$default_twohead_strategies"
 		fi ;;
 	*)
-		var="`git-config --get pull.octopus`"
+		var="`git config --get pull.octopus`"
 		if test -n "$var"
 		then
 			use_strategies="$var"
 
 case "$#" in
 1)
-	common=$(git-merge-base --all $head "$@")
+	common=$(git merge-base --all $head "$@")
 	;;
 *)
-	common=$(git-show-branch --merge-base $head "$@")
+	common=$(git show-branch --merge-base $head "$@")
 	;;
 esac
 echo "$head" >"$GIT_DIR/ORIG_HEAD"
 	;;
 ?,1,"$head",*)
 	# Again the most common case of merging one remote.
-	echo "Updating $(git-rev-parse --short $head)..$(git-rev-parse --short $1)"
-	git-update-index --refresh 2>/dev/null
+	echo "Updating $(git rev-parse --short $head)..$(git rev-parse --short $1)"
+	git update-index --refresh 2>/dev/null
 	msg="Fast forward"
 	if test -n "$have_message"
 	then
 		msg="$msg (no commit created; -m option ignored)"
 	fi
-	new_head=$(git-rev-parse --verify "$1^0") &&
-	git-read-tree -v -m -u --exclude-per-directory=.gitignore $head "$new_head" &&
+	new_head=$(git rev-parse --verify "$1^0") &&
+	git read-tree -v -m -u --exclude-per-directory=.gitignore $head "$new_head" &&
 	finish "$new_head" "$msg" || exit
 	dropsave
 	exit 0
 ?,1,*,)
 	# We are not doing octopus, not fast forward, and have only
 	# one common.
-	git-update-index --refresh 2>/dev/null
+	git update-index --refresh 2>/dev/null
 	case " $use_strategies " in
 	*' recursive '*|*' recur '*)
 		: run merge later
 		# See if it is really trivial.
 		git var GIT_COMMITTER_IDENT >/dev/null || exit
 		echo "Trying really trivial in-index merge..."
-		if git-read-tree --trivial -m -u -v $common $head "$1" &&
-		   result_tree=$(git-write-tree)
+		if git read-tree --trivial -m -u -v $common $head "$1" &&
+		   result_tree=$(git write-tree)
 		then
 			echo "Wonderful."
 			result_commit=$(
 				printf '%s\n' "$merge_msg" |
-				git-commit-tree $result_tree -p HEAD -p "$1"
+				git commit-tree $result_tree -p HEAD -p "$1"
 			) || exit
 			finish "$result_commit" "In-index merge"
 			dropsave
 	up_to_date=t
 	for remote
 	do
-		common_one=$(git-merge-base --all $head $remote)
+		common_one=$(git merge-base --all $head $remote)
 		if test "$common_one" != "$remote"
 		then
 			up_to_date=f
 	if test "$exit" -eq 1
 	then
 	    cnt=`{
-		git-diff-files --name-only
-		git-ls-files --unmerged
+		git diff-files --name-only
+		git ls-files --unmerged
 	    } | wc -l`
 	    if test $best_cnt -le 0 -o $cnt -le $best_cnt
 	    then
     }
 
     # Automerge succeeded.
-    result_tree=$(git-write-tree) && break
+    result_tree=$(git write-tree) && break
 done
 
 # If we have a resulting tree, that means the strategy module
 # auto resolved the merge cleanly.
 if test '' != "$result_tree"
 then
-    parents=$(git-show-branch --independent "$head" "$@" | sed -e 's/^/-p /')
-    result_commit=$(printf '%s\n' "$merge_msg" | git-commit-tree $result_tree $parents) || exit
+    parents=$(git show-branch --independent "$head" "$@" | sed -e 's/^/-p /')
+    result_commit=$(printf '%s\n' "$merge_msg" | git commit-tree $result_tree $parents) || exit
     finish "$result_commit" "Merge made by $wt_strategy."
     dropsave
     exit 0
 	} >>"$GIT_DIR/MERGE_MSG"
 	if test -d "$GIT_DIR/rr-cache"
 	then
-		git-rerere
+		git rerere
 	fi
 	die "Automatic merge failed; fix conflicts and then commit the result."
 fi
 	read ans
 	case "$ans" in
 	    [lL]*)
-		git-checkout-index -f --stage=2 -- "$path"
-		git-add -- "$path"
+		git checkout-index -f --stage=2 -- "$path"
+		git add -- "$path"
 		cleanup_temp_files --save-backup
 		return
 		;;
 	    [rR]*)
-		git-checkout-index -f --stage=3 -- "$path"
-		git-add -- "$path"
+		git checkout-index -f --stage=3 -- "$path"
+		git add -- "$path"
 		cleanup_temp_files --save-backup
 		return
 		;;
 	read ans
 	case "$ans" in
 	    [mMcC]*)
-		git-add -- "$path"
+		git add -- "$path"
 		cleanup_temp_files --save-backup
 		return
 		;;
 	    [dD]*)
-		git-rm -- "$path" > /dev/null
+		git rm -- "$path" > /dev/null
 		cleanup_temp_files
 		return
 		;;
 merge_file () {
     path="$1"
 
-    f=`git-ls-files -u -- "$path"`
+    f=`git ls-files -u -- "$path"`
     if test -z "$f" ; then
 	if test ! -f "$path" ; then
 	    echo "$path: file not found"
 done
 
 if test -z "$merge_tool"; then
-    merge_tool=`git-config merge.tool`
+    merge_tool=`git config merge.tool`
     case "$merge_tool" in
 	kdiff3 | tkdiff | xxdiff | meld | opendiff | emerge | vimdiff | gvimdiff | "")
 	    ;; # happy

git-parse-remote.sh

 
 # git-ls-remote could be called from outside a git managed repository;
 # this would fail in that case and would issue an error message.
-GIT_DIR=$(git-rev-parse --git-dir 2>/dev/null) || :;
+GIT_DIR=$(git rev-parse --git-dir 2>/dev/null) || :;
 
 get_data_source () {
 	case "$1" in
 		echo self
 		;;
 	*)
-		if test "$(git-config --get "remote.$1.url")"
+		if test "$(git config --get "remote.$1.url")"
 		then
 			echo config
 		elif test -f "$GIT_DIR/remotes/$1"
 		echo "$1"
 		;;
 	config)
-		git-config --get "remote.$1.url"
+		git config --get "remote.$1.url"
 		;;
 	remotes)
 		sed -ne '/^URL: */{
 }
 
 get_default_remote () {
-	curr_branch=$(git-symbolic-ref -q HEAD | sed -e 's|^refs/heads/||')
-	origin=$(git-config --get "branch.$curr_branch.remote")
+	curr_branch=$(git symbolic-ref -q HEAD | sed -e 's|^refs/heads/||')
+	origin=$(git config --get "branch.$curr_branch.remote")
 	echo ${origin:-origin}
 }
 
 	'' | branches | self)
 		;; # no default push mapping, just send matching refs.
 	config)
-		git-config --get-all "remote.$1.push" ;;
+		git config --get-all "remote.$1.push" ;;
 	remotes)
 		sed -ne '/^Push: */{
 			s///p
 		shift
 		if test "$remote" = "$(get_default_remote)"
 		then
-			curr_branch=$(git-symbolic-ref -q HEAD | \
+			curr_branch=$(git symbolic-ref -q HEAD | \
 			    sed -e 's|^refs/heads/||')
-			merge_branches=$(git-config \
+			merge_branches=$(git config \
 			    --get-all "branch.${curr_branch}.merge")
 		fi
 		if test -z "$merge_branches" && test $is_explicit != explicit
 
 		if local_ref_name=$(expr "z$local" : 'zrefs/\(.*\)')
 		then
-		   git-check-ref-format "$local_ref_name" ||
+		   git check-ref-format "$local_ref_name" ||
 		   die "* refusing to create funny ref '$local_ref_name' locally"
 		fi
 		echo "${dot_prefix}${force}${remote}:${local}"
 		echo "HEAD:" ;;
 	self)
 	        canon_refs_list_for_fetch -d "$1" \
-			$(git-for-each-ref --format='%(refname):')
+			$(git for-each-ref --format='%(refname):')
 		;;
 	config)
 		canon_refs_list_for_fetch -d "$1" \
-			$(git-config --get-all "remote.$1.fetch") ;;
+			$(git config --get-all "remote.$1.fetch") ;;
 	branches)
 		remote_branch=$(sed -ne '/#/s/.*#//p' "$GIT_DIR/branches/$1")
 		case "$remote_branch" in '') remote_branch=master ;; esac
 	data_source=$(get_data_source "$1")
 	case "$data_source" in
 	config)
-		uplp=$(git-config --get "remote.$1.uploadpack")
+		uplp=$(git config --get "remote.$1.uploadpack")
 		echo ${uplp:-git-upload-pack}
 		;;
 	*)
 	shift
 done
 
-orig_head=$(git-rev-parse --verify HEAD 2>/dev/null)
+orig_head=$(git rev-parse --verify HEAD 2>/dev/null)
 git-fetch --update-head-ok "$@" || exit 1
 
-curr_head=$(git-rev-parse --verify HEAD 2>/dev/null)
+curr_head=$(git rev-parse --verify HEAD 2>/dev/null)
 if test "$curr_head" != "$orig_head"
 then
 	# The fetch involved updating the current branch.
 	echo >&2 "Warning: fetch updated the current branch head."
 	echo >&2 "Warning: fast forwarding your working tree from"
 	echo >&2 "Warning: commit $orig_head."
-	git-update-index --refresh 2>/dev/null
-	git-read-tree -u -m "$orig_head" "$curr_head" ||
+	git update-index --refresh 2>/dev/null
+	git read-tree -u -m "$orig_head" "$curr_head" ||
 		die 'Cannot fast-forward your working tree.
 After making sure that you saved anything precious from
 $ git diff '$orig_head'
 
 case "$merge_head" in
 '')
-	curr_branch=$(git-symbolic-ref -q HEAD)
+	curr_branch=$(git symbolic-ref -q HEAD)
 	case $? in
 	  0) ;;
 	  1) echo >&2 "You are not currently on a branch; you must explicitly"
 
 if test -z "$orig_head"
 then
-	git-update-ref -m "initial pull" HEAD $merge_head "" &&
-	git-read-tree --reset -u HEAD || exit 1
+	git update-ref -m "initial pull" HEAD $merge_head "" &&
+	git read-tree --reset -u HEAD || exit 1
 	exit
 fi
 
-merge_name=$(git-fmt-merge-msg <"$GIT_DIR/FETCH_HEAD") || exit
+merge_name=$(git fmt-merge-msg <"$GIT_DIR/FETCH_HEAD") || exit
 exec git-merge $no_summary $no_commit $squash $strategy_args \
 	"$merge_name" HEAD $merge_head

git-quiltimport.sh

 
 
 # Find the intial commit
-commit=$(git-rev-parse HEAD)
+commit=$(git rev-parse HEAD)
 
 mkdir $tmp_dir || exit 2
 for patch_name in $(cat "$QUILT_PATCHES/series" | grep -v '^#'); do
 	echo $patch_name
-	(cat $QUILT_PATCHES/$patch_name | git-mailinfo "$tmp_msg" "$tmp_patch" > "$tmp_info") || exit 3
+	(cat $QUILT_PATCHES/$patch_name | git mailinfo "$tmp_msg" "$tmp_patch" > "$tmp_info") || exit 3
 	test -s .dotest/patch || {
 		echo "Patch is empty.  Was it split wrong?"
 		exit 1
 	fi
 
 	if [ -z "$dry_run" ] ; then
-		git-apply --index -C1 "$tmp_patch" &&
-		tree=$(git-write-tree) &&
-		commit=$( (echo "$SUBJECT"; echo; cat "$tmp_msg") | git-commit-tree $tree -p $commit) &&
-		git-update-ref -m "quiltimport: $patch_name" HEAD $commit || exit 4
+		git apply --index -C1 "$tmp_patch" &&
+		tree=$(git write-tree) &&
+		commit=$( (echo "$SUBJECT"; echo; cat "$tmp_msg") | git commit-tree $tree -p $commit) &&
+		git update-ref -m "quiltimport: $patch_name" HEAD $commit || exit 4
 	fi
 done
 rm -rf $tmp_dir || exit 5
 	test -n "$prev_head" || die "prev_head must be defined"
 	test -d "$dotest" || die "$dotest directory does not exist"
 
-	unmerged=$(git-ls-files -u)
+	unmerged=$(git ls-files -u)
 	if test -n "$unmerged"
 	then
 		echo "You still have unmerged paths in your index"
 		die "$RESOLVEMSG"
 	fi
 
-	if ! git-diff-index --quiet HEAD
+	if ! git diff-index --quiet HEAD
 	then
 		if ! git-commit -C "`cat $dotest/current`"
 		then
 	else
 		printf "Already applied: %0${prec}d" $msgnum
 	fi
-	echo ' '`git-rev-list --pretty=oneline -1 HEAD | \
+	echo ' '`git rev-list --pretty=oneline -1 HEAD | \
 				sed 's/^[a-f0-9]\+ //'`
 
-	prev_head=`git-rev-parse HEAD^0`
+	prev_head=`git rev-parse HEAD^0`
 	# save the resulting commit so we can read-tree on it later
 	echo "$prev_head" > "$dotest/prev_head"
 
 call_merge () {
 	cmt="$(cat $dotest/cmt.$1)"
 	echo "$cmt" > "$dotest/current"
-	hd=$(git-rev-parse --verify HEAD)
-	cmt_name=$(git-symbolic-ref HEAD)
+	hd=$(git rev-parse --verify HEAD)
+	cmt_name=$(git symbolic-ref HEAD)
 	msgnum=$(cat $dotest/msgnum)
 	end=$(cat $dotest/end)
 	eval GITHEAD_$cmt='"${cmt_name##refs/heads/}~$(($end - $msgnum))"'
 		return
 		;;
 	1)
-		test -d "$GIT_DIR/rr-cache" && git-rerere
+		test -d "$GIT_DIR/rr-cache" && git rerere
 		die "$RESOLVEMSG"
 		;;
 	2)
 do
 	case "$1" in
 	--continue)
-		git-diff-files --quiet || {
+		git diff-files --quiet || {
 			echo "You must edit all merge conflicts and then"
 			echo "mark them as resolved using git add"
 			exit 1
 		then
 			if test -d "$GIT_DIR/rr-cache"
 			then
-				git-rerere clear
+				git rerere clear
 			fi
 			prev_head="`cat $dotest/prev_head`"
 			end="`cat $dotest/end`"
 	--abort)
 		if test -d "$GIT_DIR/rr-cache"
 		then
-			git-rerere clear
+			git rerere clear
 		fi
 		if test -d "$dotest"
 		then
 fi
 
 # The tree must be really really clean.
-git-update-index --refresh || exit
-diff=$(git-diff-index --cached --name-status -r HEAD)
+git update-index --refresh || exit
+diff=$(git diff-index --cached --name-status -r HEAD)
 case "$diff" in
 ?*)	echo "cannot rebase: your index is not up-to-date"
 	echo "$diff"
 
 # Make sure the branch to rebase onto is valid.
 onto_name=${newbase-"$upstream_name"}
-onto=$(git-rev-parse --verify "${onto_name}^0") || exit
+onto=$(git rev-parse --verify "${onto_name}^0") || exit
 
 # If a hook exists, give it a chance to interrupt
 if test -x "$GIT_DIR/hooks/pre-rebase"
 	fi
 	;;
 esac
-branch=$(git-rev-parse --verify "${branch_name}^0") || exit
+branch=$(git rev-parse --verify "${branch_name}^0") || exit
 
 # Now we are rebasing commits $upstream..$branch on top of $onto
 
 # Check if we are already based on $onto, but this should be
 # done only when upstream and onto are the same.
-mb=$(git-merge-base "$onto" "$branch")
+mb=$(git merge-base "$onto" "$branch")
 if test "$upstream" = "$onto" && test "$mb" = "$onto"
 then
 	echo >&2 "Current branch $branch_name is up to date."
 then
 	echo "Changes from $mb to $onto:"
 	# We want color (if set), but no pager
-	GIT_PAGER='' git-diff --stat --summary "$mb" "$onto"
+	GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
 fi
 
 # Rewind the head to "$onto"; this saves our current head in ORIG_HEAD.
 
 if test -z "$do_merge"
 then
-	git-format-patch -k --stdout --full-index --ignore-if-in-upstream "$upstream"..ORIG_HEAD |
+	git format-patch -k --stdout --full-index --ignore-if-in-upstream "$upstream"..ORIG_HEAD |
 	git am $git_am_opt --binary -3 -k --resolvemsg="$RESOLVEMSG"
 	exit $?
 fi
 mkdir -p "$dotest"
 echo "$onto" > "$dotest/onto"
 echo "$onto_name" > "$dotest/onto_name"
-prev_head=`git-rev-parse HEAD^0`
+prev_head=`git rev-parse HEAD^0`
 echo "$prev_head" > "$dotest/prev_head"
 
 msgnum=0
-for cmt in `git-rev-list --reverse --no-merges "$upstream"..ORIG_HEAD`
+for cmt in `git rev-list --reverse --no-merges "$upstream"..ORIG_HEAD`
 do
 	msgnum=$(($msgnum + 1))
 	echo "$cmt" > "$dotest/cmt.$msgnum"
 esac
 
 args="$args $local $quiet $no_reuse$extra"
-names=$(git-pack-objects --non-empty --all --reflog $args </dev/null "$PACKTMP") ||
+names=$(git pack-objects --non-empty --all --reflog $args </dev/null "$PACKTMP") ||
 	exit 1
 if [ -z "$names" ]; then
 	echo Nothing new to pack.
 		  done
 		)
 	fi
-	git-prune-packed $quiet
+	git prune-packed $quiet
 fi
 
 case "$no_update_info" in

git-request-pull.sh

 [ "$base" ] || usage
 [ "$url" ] || usage
 
-baserev=`git-rev-parse --verify "$base"^0` &&
-headrev=`git-rev-parse --verify "$head"^0` || exit
+baserev=`git rev-parse --verify "$base"^0` &&
+headrev=`git rev-parse --verify "$head"^0` || exit
 
 merge_base=`git merge-base $baserev $headrev` ||
 die "fatal: No commits in common between $base and $head"
 		usage
 		;;
 	*)
-		rev=$(git-rev-parse --verify "$1") || exit
+		rev=$(git rev-parse --verify "$1") || exit
 		shift
 		break
 		;;
 done
 
 : ${rev=HEAD}
-rev=$(git-rev-parse --verify $rev^0) || exit
+rev=$(git rev-parse --verify $rev^0) || exit
 
 # Skip -- in "git reset HEAD -- foo" and "git reset -- foo".
 case "$1" in --) shift ;; esac
 	test "$reset_type" = "--mixed" ||
 		die "Cannot do partial $reset_type reset."
 
-	git-diff-index --cached $rev -- "$@" |
+	git diff-index --cached $rev -- "$@" |
 	sed -e 's/^:\([0-7][0-7]*\) [0-7][0-7]* \([0-9a-f][0-9a-f]*\) [0-9a-f][0-9a-f]* [A-Z]	\(.*\)$/\1 \2	\3/' |
 	git update-index --add --remove --index-info || exit
 	git update-index --refresh
 if test "$reset_type" = "--soft"
 then
 	if test -f "$GIT_DIR/MERGE_HEAD" ||
-	   test "" != "$(git-ls-files --unmerged)"
+	   test "" != "$(git ls-files --unmerged)"
 	then
 		die "Cannot do a soft reset in the middle of a merge."
 	fi
 else
-	git-read-tree -v --reset $update "$rev" || exit
+	git read-tree -v --reset $update "$rev" || exit
 fi
 
 # Any resets update HEAD to the head being switched to.
-if orig=$(git-rev-parse --verify HEAD 2>/dev/null)
+if orig=$(git rev-parse --verify HEAD 2>/dev/null)
 then
 	echo "$orig" >"$GIT_DIR/ORIG_HEAD"
 else
 	rm -f "$GIT_DIR/ORIG_HEAD"
 fi
-git-update-ref -m "$GIT_REFLOG_ACTION" HEAD "$rev"
+git update-ref -m "$GIT_REFLOG_ACTION" HEAD "$rev"
 update_ref_status=$?
 
 case "$reset_type" in