From 667bb59b2d5b0a2e7fca5970d6f757790a6edd74 Mon Sep 17 00:00:00 2001
From: Alexey Nezhdanov <snake@penza-gsm.ru>
Date: Thu, 19 May 2005 15:17:16 +0400
Subject: [PATCH] cleanup of in-code names

Fixes all in-code names that leaved during "big name change".

Signed-off-by: Alexey Nezhdanov <snake@penza-gsm.ru>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/checkout-cache.c b/checkout-cache.c
index bc486ba..9cd289c 100644
--- a/checkout-cache.c
+++ b/checkout-cache.c
@@ -5,22 +5,22 @@
  *
  * Careful: order of argument flags does matter. For example,
  *
- *	checkout-cache -a -f file.c
+ *	git-checkout-cache -a -f file.c
  *
  * Will first check out all files listed in the cache (but not
  * overwrite any old ones), and then force-checkout "file.c" a
  * second time (ie that one _will_ overwrite any old contents
  * with the same filename).
  *
- * Also, just doing "checkout-cache" does nothing. You probably
- * meant "checkout-cache -a". And if you want to force it, you
- * want "checkout-cache -f -a".
+ * Also, just doing "git-checkout-cache" does nothing. You probably
+ * meant "git-checkout-cache -a". And if you want to force it, you
+ * want "git-checkout-cache -f -a".
  *
  * Intuitiveness is not the goal here. Repeatability is. The
  * reason for the "no arguments means no work" thing is that
  * from scripts you are supposed to be able to do things like
  *
- *	find . -name '*.h' -print0 | xargs -0 checkout-cache -f --
+ *	find . -name '*.h' -print0 | xargs -0 git-checkout-cache -f --
  *
  * which will force all existing *.h files to be replaced with
  * their cached copies. If an empty command line implied "all",
@@ -122,7 +122,7 @@ static int write_entry(struct cache_entry *ce, const char *path)
 	if (!new || strcmp(type, "blob")) {
 		if (new)
 			free(new);
-		return error("checkout-cache: unable to read sha1 file of %s (%s)",
+		return error("git-checkout-cache: unable to read sha1 file of %s (%s)",
 			path, sha1_to_hex(ce->sha1));
 	}
 	switch (ntohl(ce->ce_mode) & S_IFMT) {
@@ -130,14 +130,14 @@ static int write_entry(struct cache_entry *ce, const char *path)
 		fd = create_file(path, ntohl(ce->ce_mode));
 		if (fd < 0) {
 			free(new);
-			return error("checkout-cache: unable to create file %s (%s)",
+			return error("git-checkout-cache: unable to create file %s (%s)",
 				path, strerror(errno));
 		}
 		wrote = write(fd, new, size);
 		close(fd);
 		free(new);
 		if (wrote != size)
-			return error("checkout-cache: unable to write file %s", path);
+			return error("git-checkout-cache: unable to write file %s", path);
 		break;
 	case S_IFLNK:
 		memcpy(target, new, size);
@@ -145,14 +145,14 @@ static int write_entry(struct cache_entry *ce, const char *path)
 		create_directories(path);
 		if (symlink(target, path)) {
 			free(new);
-			return error("checkout-cache: unable to create symlink %s (%s)",
+			return error("git-checkout-cache: unable to create symlink %s (%s)",
 				path, strerror(errno));
 		}
 		free(new);
 		break;
 	default:
 		free(new);
-		return error("checkout-cache: unknown file mode for %s", path);
+		return error("git-checkout-cache: unknown file mode for %s", path);
 	}
 
 	if (refresh_cache) {
@@ -178,7 +178,7 @@ static int checkout_entry(struct cache_entry *ce, const char *base_dir)
 			return 0;
 		if (!force) {
 			if (!quiet)
-				fprintf(stderr, "checkout-cache: %s already exists\n", path);
+				fprintf(stderr, "git-checkout-cache: %s already exists\n", path);
 			return 0;
 		}
 
@@ -201,7 +201,7 @@ static int checkout_file(const char *name, const char *base_dir)
 		if (!quiet) {
 			pos = -pos - 1;
 			fprintf(stderr,
-				"checkout-cache: %s is %s.\n",
+				"git-checkout-cache: %s is %s.\n",
 				name,
 				(pos < active_nr &&
 				 !strcmp(active_cache[pos]->name, name)) ?
diff --git a/commit-tree.c b/commit-tree.c
index b8dd36f..e6f001e 100644
--- a/commit-tree.c
+++ b/commit-tree.c
@@ -98,7 +98,7 @@ static void check_valid(unsigned char *sha1, const char *expect)
  */
 #define MAXPARENT (16)
 
-static char *commit_tree_usage = "commit-tree <sha1> [-p <sha1>]* < changelog";
+static char *commit_tree_usage = "git-commit-tree <sha1> [-p <sha1>]* < changelog";
 
 int main(int argc, char **argv)
 {
diff --git a/convert-cache.c b/convert-cache.c
index 93e477a..77f8bff 100644
--- a/convert-cache.c
+++ b/convert-cache.c
@@ -304,7 +304,7 @@ int main(int argc, char **argv)
 	struct entry *entry;
 
 	if (argc != 2 || get_sha1(argv[1], sha1))
-		usage("convert-cache <sha1>");
+		usage("git-convert-cache <sha1>");
 
 	entry = convert_entry(sha1);
 	printf("new sha1: %s\n", sha1_to_hex(entry->new_sha1));
diff --git a/diff-cache.c b/diff-cache.c
index 2bdea9c..8f32bee 100644
--- a/diff-cache.c
+++ b/diff-cache.c
@@ -181,7 +181,7 @@ int main(int argc, char **argv)
 		argv++;
 		argc--;
 		if (!strcmp(arg, "-r")) {
-			/* We accept the -r flag just to look like diff-tree */
+			/* We accept the -r flag just to look like git-diff-tree */
 			continue;
 		}
 		if (!strcmp(arg, "-p")) {
diff --git a/diff-files.c b/diff-files.c
index 7ffe663..fb345a5 100644
--- a/diff-files.c
+++ b/diff-files.c
@@ -7,7 +7,7 @@
 #include "diff.h"
 
 static const char *diff_files_usage =
-"diff-files [-p] [-q] [-r] [-z] [-M] [paths...]";
+"git-diff-files [-p] [-q] [-r] [-z] [-M] [paths...]";
 
 static int generate_patch = 0;
 static int line_termination = '\n';
diff --git a/diff-tree.c b/diff-tree.c
index 34c868d..d3d83bd 100644
--- a/diff-tree.c
+++ b/diff-tree.c
@@ -259,7 +259,7 @@ static int diff_tree(void *tree1, unsigned long size1, void *tree2, unsigned lon
 			update_tree_entry(&tree2, &size2);
 			continue;
 		}
-		die("diff-tree: internal error");
+		die("git-diff-tree: internal error");
 	}
 	return 0;
 }
@@ -421,7 +421,7 @@ static int diff_tree_stdin(char *line)
 }
 
 static char *diff_tree_usage =
-"diff-tree [-p] [-r] [-z] [--stdin] [-M] [-m] [-s] [-v] <tree-ish> <tree-ish>";
+"git-diff-tree [-p] [-r] [-z] [--stdin] [-M] [-m] [-s] [-v] <tree-ish> <tree-ish>";
 
 int main(int argc, char **argv)
 {
diff --git a/fsck-cache.c b/fsck-cache.c
index c4b1c1a..32fa5d5 100644
--- a/fsck-cache.c
+++ b/fsck-cache.c
@@ -152,7 +152,7 @@ static int fsck_tree(struct tree *item)
 	}
 
 	if (has_full_path) {
-		fprintf(stderr, "warning: fsck-cache: tree %s "
+		fprintf(stderr, "warning: git-fsck-cache: tree %s "
 			"has full pathnames in it\n", 
 			sha1_to_hex(item->object.sha1));
 	}
@@ -385,7 +385,7 @@ int main(int argc, char **argv)
 			continue;
 		}
 		if (*arg == '-')
-			usage("fsck-cache [--tags] [[--unreachable] [--cache] <head-sha1>*]");
+			usage("git-fsck-cache [--tags] [[--unreachable] [--cache] <head-sha1>*]");
 	}
 
 	sha1_dir = get_object_directory();
diff --git a/ls-files.c b/ls-files.c
index 76782f6..214bd4a 100644
--- a/ls-files.c
+++ b/ls-files.c
@@ -283,7 +283,7 @@ static void show_files(void)
 }
 
 static const char *ls_files_usage =
-	"ls-files [-z] [-t] (--[cached|deleted|others|stage|unmerged|killed])* "
+	"git-ls-files [-z] [-t] (--[cached|deleted|others|stage|unmerged|killed])* "
 	"[ --ignored [--exclude=<pattern>] [--exclude-from=<file>) ]";
 
 int main(int argc, char **argv)
diff --git a/ls-tree.c b/ls-tree.c
index a69eac8..30dfcdd 100644
--- a/ls-tree.c
+++ b/ls-tree.c
@@ -81,7 +81,7 @@ static int list(unsigned char *sha1)
 	return 0;
 }
 
-static const char *ls_tree_usage = "ls-tree [-r] [-z] <key>";
+static const char *ls_tree_usage = "git-ls-tree [-r] [-z] <key>";
 
 int main(int argc, char **argv)
 {
diff --git a/merge-base.c b/merge-base.c
index 6aa7f56..04f40fc 100644
--- a/merge-base.c
+++ b/merge-base.c
@@ -60,7 +60,7 @@ int main(int argc, char **argv)
 	if (argc != 3 ||
 	    get_sha1(argv[1], rev1key) ||
 	    get_sha1(argv[2], rev2key)) {
-		usage("merge-base <commit-id> <commit-id>");
+		usage("git-merge-base <commit-id> <commit-id>");
 	}
 	rev1 = lookup_commit_reference(rev1key);
 	rev2 = lookup_commit_reference(rev2key);
diff --git a/merge-cache.c b/merge-cache.c
index 4841233..37c72d2 100644
--- a/merge-cache.c
+++ b/merge-cache.c
@@ -39,7 +39,7 @@ static int merge_entry(int pos, const char *path)
 	int found;
 	
 	if (pos >= active_nr)
-		die("merge-cache: %s not in the cache", path);
+		die("git-merge-cache: %s not in the cache", path);
 	arguments[0] = pgm;
 	arguments[1] = "";
 	arguments[2] = "";
@@ -64,7 +64,7 @@ static int merge_entry(int pos, const char *path)
 		arguments[stage + 4] = ownbuf[stage];
 	} while (++pos < active_nr);
 	if (!found)
-		die("merge-cache: %s not in the cache", path);
+		die("git-merge-cache: %s not in the cache", path);
 	run_program();
 	return found;
 }
@@ -97,7 +97,7 @@ int main(int argc, char **argv)
 	int i, force_file = 0;
 
 	if (argc < 3)
-		usage("merge-cache [-o] <merge-program> (-a | <filename>*)");
+		usage("git-merge-cache [-o] <merge-program> (-a | <filename>*)");
 
 	read_cache();
 
@@ -118,7 +118,7 @@ int main(int argc, char **argv)
 				merge_all();
 				continue;
 			}
-			die("merge-cache: unknown option %s", arg);
+			die("git-merge-cache: unknown option %s", arg);
 		}
 		merge_file(arg);
 	}
diff --git a/read-tree.c b/read-tree.c
index f6298e5..c5f26d5 100644
--- a/read-tree.c
+++ b/read-tree.c
@@ -159,7 +159,7 @@ static void merge_stat_info(struct cache_entry **src, int nr)
 	}
 }
 
-static char *read_tree_usage = "read-tree (<sha> | -m <sha1> [<sha2> <sha3>])";
+static char *read_tree_usage = "git-read-tree (<sha> | -m <sha1> [<sha2> <sha3>])";
 
 int main(int argc, char **argv)
 {
diff --git a/rev-list.c b/rev-list.c
index 345e24c..94e52d2 100644
--- a/rev-list.c
+++ b/rev-list.c
@@ -27,7 +27,7 @@ int main(int argc, char **argv)
 	}
 
 	if (!commit_arg || get_sha1(commit_arg, sha1))
-		usage("usage: rev-list [OPTION] commit-id\n"
+		usage("usage: git-rev-list [OPTION] commit-id\n"
 		      "  --max-count=nr\n"
 		      "  --max-age=epoch\n"
 		      "  --min-age=epoch\n");
diff --git a/rev-tree.c b/rev-tree.c
index c2909da..f7dc98b 100644
--- a/rev-tree.c
+++ b/rev-tree.c
@@ -64,7 +64,7 @@ void process_commit(unsigned char *sha1)
 }
 
 /*
- * Usage: rev-tree [--edges] [--cache <cache-file>] <commit-id> [<commit-id2>]
+ * Usage: git-rev-tree [--edges] [--cache <cache-file>] <commit-id> [<commit-id2>]
  *
  * The cache-file can be quite important for big trees. This is an
  * expensive operation if you have to walk the whole chain of
@@ -98,7 +98,7 @@ int main(int argc, char **argv)
 			basemask |= 1<<nr;
 		}
 		if (nr >= MAX_COMMITS || get_sha1(arg, sha1[nr]))
-			usage("rev-tree [--edges] [--cache <cache-file>] <commit-id> [<commit-id>]");
+			usage("git-rev-tree [--edges] [--cache <cache-file>] <commit-id> [<commit-id>]");
 		process_commit(sha1[nr]);
 		nr++;
 	}
diff --git a/rpush.c b/rpush.c
index 3f2c898..223bdd8 100644
--- a/rpush.c
+++ b/rpush.c
@@ -14,7 +14,7 @@ void service(int fd_in, int fd_out) {
 		do {
 			size = read(fd_in, sha1 + posn, 20 - posn);
 			if (size < 0) {
-				perror("rpush: read ");
+				perror("git-rpush: read ");
 				return;
 			}
 			if (!size)
@@ -26,7 +26,7 @@ void service(int fd_in, int fd_out) {
 
 		buf = map_sha1_file(sha1, &objsize);
 		if (!buf) {
-			fprintf(stderr, "rpush: could not find %s\n", 
+			fprintf(stderr, "git-rpush: could not find %s\n", 
 				sha1_to_hex(sha1));
 			return;
 		}
@@ -35,9 +35,9 @@ void service(int fd_in, int fd_out) {
 			size = write(fd_out, buf + posn, objsize - posn);
 			if (size <= 0) {
 				if (!size) {
-					fprintf(stderr, "rpush: write closed");
+					fprintf(stderr, "git-rpush: write closed");
 				} else {
-					perror("rpush: write ");
+					perror("git-rpush: write ");
 				}
 				return;
 			}
@@ -56,7 +56,7 @@ int main(int argc, char **argv)
                 arg++;
         }
         if (argc < arg + 2) {
-                usage("rpush [-c] [-t] [-a] commit-id url");
+                usage("git-rpush [-c] [-t] [-a] commit-id url");
                 return 1;
         }
 	commit_id = argv[arg];
diff --git a/tar-tree.c b/tar-tree.c
index f6df372..ccc39c9 100644
--- a/tar-tree.c
+++ b/tar-tree.c
@@ -17,7 +17,7 @@
 #define EXT_HEADER_PATH		1
 #define EXT_HEADER_LINKPATH	2
 
-static const char *tar_tree_usage = "tar-tree <key> [basedir]";
+static const char *tar_tree_usage = "git-tar-tree <key> [basedir]";
 
 static char block[BLOCKSIZE];
 static unsigned long offset;
@@ -40,9 +40,9 @@ static void reliable_write(void *buf, unsigned long size)
 				continue;
 			if (errno == EPIPE)
 				exit(0);
-			die("tar-tree: %s", strerror(errno));
+			die("git-tar-tree: %s", strerror(errno));
 		} else if (!ret) {
-			die("tar-tree: disk full?");
+			die("git-tar-tree: disk full?");
 		}
 		size -= ret;
 		buf += ret;
diff --git a/unpack-file.c b/unpack-file.c
index b7988c5..d4ac3a5 100644
--- a/unpack-file.c
+++ b/unpack-file.c
@@ -27,7 +27,7 @@ int main(int argc, char **argv)
 	unsigned char sha1[20];
 
 	if (argc != 2 || get_sha1(argv[1], sha1))
-		usage("unpack-file.c <sha1>");
+		usage("git-unpack-file <sha1>");
 
 	puts(create_temp_file(sha1));
 	return 0;
diff --git a/update-cache.c b/update-cache.c
index e0ad09c..a956953 100644
--- a/update-cache.c
+++ b/update-cache.c
@@ -9,7 +9,7 @@
  * Default to not allowing changes to the list of files. The
  * tool doesn't actually care, but this makes it harder to add
  * files to the revision control by mistake by doing something
- * like "update-cache *" and suddenly having all the object
+ * like "git-update-cache *" and suddenly having all the object
  * files be revision controlled.
  */
 static int allow_add = 0, allow_remove = 0, allow_replace = 0, not_new = 0;
@@ -158,7 +158,7 @@ static int compare_link(struct cache_entry *ce, unsigned long expected_size)
  * file that hasn't been changed but where the stat entry is
  * out of date.
  *
- * For example, you'd want to do this after doing a "read-tree",
+ * For example, you'd want to do this after doing a "git-read-tree",
  * to link up the stat cache details with the proper files.
  */
 static struct cache_entry *refresh_entry(struct cache_entry *ce)
@@ -333,17 +333,17 @@ int main(int argc, char **argv)
 			}
 			if (!strcmp(path, "--cacheinfo")) {
 				if (i+3 >= argc)
-					die("update-cache: --cacheinfo <mode> <sha1> <path>");
+					die("git-update-cache: --cacheinfo <mode> <sha1> <path>");
 				if (add_cacheinfo(argv[i+1], argv[i+2], argv[i+3]))
-					die("update-cache: --cacheinfo cannot add %s", argv[i+3]);
+					die("git-update-cache: --cacheinfo cannot add %s", argv[i+3]);
 				i += 3;
 				continue;
 			}
 			if (!strcmp(path, "--force-remove")) {
 				if (argc <= i + 1)
-					die("update-cache: --force-remove <path>");
+					die("git-update-cache: --force-remove <path>");
 				if (remove_file_from_cache(argv[i+1]))
-					die("update-cache: --force-remove cannot remove %s", argv[i+1]);
+					die("git-update-cache: --force-remove cannot remove %s", argv[i+1]);
 				i++;
 				continue;
 			}
diff --git a/write-tree.c b/write-tree.c
index e3c0a02..b8bf883 100644
--- a/write-tree.c
+++ b/write-tree.c
@@ -89,7 +89,7 @@ int main(int argc, char **argv)
 	unsigned char sha1[20];
 
 	if (entries < 0)
-		die("write-tree: error reading cache");
+		die("git-write-tree: error reading cache");
 
 	/* Verify that the tree is merged */
 	funny = 0;
@@ -104,7 +104,7 @@ int main(int argc, char **argv)
 		}
 	}
 	if (funny)
-		die("write-tree: not able to write tree");
+		die("git-write-tree: not able to write tree");
 
 	/* Also verify that the cache does not have path and path/file
 	 * at the same time.  At this point we know the cache has only
@@ -131,11 +131,11 @@ int main(int argc, char **argv)
 		}
 	}
 	if (funny)
-		die("write-tree: not able to write tree");
+		die("git-write-tree: not able to write tree");
 
 	/* Ok, write it out */
 	if (write_tree(active_cache, entries, "", 0, sha1) != entries)
-		die("write-tree: internal error");
+		die("git-write-tree: internal error");
 	printf("%s\n", sha1_to_hex(sha1));
 	return 0;
 }
-- 
cgit v0.10.2-6-g49f6