[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 bc486ba07273f6836084644e80897bb1d4b9e27c..9cd289c35a8707feaa8c2c5ea1e6591c00fb0a12 100644 (file)
--- 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 b8dd36f0b8d7b1c49a478b1aae42de5d594897ab..e6f001ea279b4d64d427495da91cc7737e2faa80 100644 (file)
--- 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 93e477ad3b26ab5bb32fe1b638d5ba77075c1d4b..77f8bff9ac0cd61412e69921c610e7301f7c350b 100644 (file)
--- 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 2bdea9cc3aecb3bf75c0a0e56fe6b54640390e18..8f32beed10f6d5e9f745fab3603d390353d4601d 100644 (file)
--- 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 7ffe66361226234f62cd27ba2d8fe22cf79c51f2..fb345a5161c2a49ea36f697197fde057248b687b 100644 (file)
--- 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 34c868d3ab9b28652d70f3546f47d3adfc62cba5..d3d83bd8df2d89a6440b0978826e1e0550c4e837 100644 (file)
--- 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 c4b1c1ae60c050d3d0645f90014fe7e30f82f284..32fa5d53e54f253720c165c6b3a5a6e1c4a44f9a 100644 (file)
--- 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 76782f691956ba2562b4757e08d6e7fa626dd3ea..214bd4a8d15611ec183191717e5457a6961a77e5 100644 (file)
--- 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 a69eac87a8db3da6d13ecf28d70609e20941f00c..30dfcddf74b2d97d9ee2d54bfbb5bfa5cb3160ee 100644 (file)
--- 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 6aa7f56526132dc0294717a3d3066ff568c33c38..04f40fc8c57b2531393532e9f62de229a07224a4 100644 (file)
--- 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 48412330cb950813b37d7254947a3f70a4fd99d8..37c72d26ca587bd700412cd9d7cd99b08fd2da3a 100644 (file)
--- 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 f6298e5c2178ee8e5f898ea769ae7108d1a7cfbd..c5f26d5f801504f24d734d8cd84d931769bf54c5 100644 (file)
--- 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 345e24c2919ef48bdc9cfdb9e6ec71b487c5e01f..94e52d2edf78f8fce4c8f6dce290f4f13ca901b3 100644 (file)
--- 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 c2909da1722b48be394311d9cc70cf78ec81e411..f7dc98b1aaacacedeef059b3424d0a42259bb9b8 100644 (file)
--- 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 3f2c898c8f5cf5ba62d689a13c646936b8372ee7..223bdd81f3303f4f6fd7493f94a8f7f39aacffee 100644 (file)
--- 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 f6df3722a8916ea15b691602d943e49a3c3d7381..ccc39c92a0416fa12a1e261b4a147139dc710b2c 100644 (file)
--- 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 b7988c5575fabd57100d25742a1d0578bcc181d7..d4ac3a5460568408f96fc26e5228c639dfc20439 100644 (file)
--- 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 e0ad09c385068948527f990ee695c0d65fc1e4f6..a9569533e12978041100e6013c3c3f3161c002b0 100644 (file)
--- 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 e3c0a02310a01775741bae0d937333930f14cd3f..b8bf8831e09facf19bfb9673e26a885ea249285a 100644 (file)
--- 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;
 }