Use blob_, commit_, tag_, and tree_type throughout.

This replaces occurences of "blob", "commit", "tag", and "tree",
where they're really used as type specifiers, which we already
have defined global constants for.

Signed-off-by: Peter Eriksen <s022018@student.dtu.dk>
Signed-off-by: Junio C Hamano <junkio@cox.net>

diff --git a/apply.c b/apply.c
index c50b3a60464ea05307af8e8d1be576cf96415ff0..cc3f12e5557d1b6c333c890d6d0209aee74742e5 100644 (file)
--- a/apply.c
+++ b/apply.c
@@ -9,6 +9,7 @@
 #include <fnmatch.h>
 #include "cache.h"
 #include "quote.h"
 #include <fnmatch.h>
 #include "cache.h"
 #include "quote.h"

+#include "blob.h"

 
 //  --check turns on checking that the working tree matches the
 //    files that are being modified, but doesn't apply the patch
 
 //  --check turns on checking that the working tree matches the
 //    files that are being modified, but doesn't apply the patch


@@ -1296,7 +1297,7 @@ static int apply_fragments(struct buffer_desc *desc, struct patch *patch)
                         * applies to.
                         */
                        write_sha1_file_prepare(desc->buffer, desc->size,
                         * applies to.
                         */
                        write_sha1_file_prepare(desc->buffer, desc->size,

-                                               "blob", sha1, hdr, &hdrlen);
+                                               blob_type, sha1, hdr, &hdrlen);

                        if (strcmp(sha1_to_hex(sha1), patch->old_sha1_prefix))
                                return error("the patch applies to '%s' (%s), "
                                             "which does not match the "
                        if (strcmp(sha1_to_hex(sha1), patch->old_sha1_prefix))
                                return error("the patch applies to '%s' (%s), "
                                             "which does not match the "


@@ -1659,7 +1660,7 @@ static void add_index_file(const char *path, unsigned mode, void *buf, unsigned
        if (lstat(path, &st) < 0)
                die("unable to stat newly created file %s", path);
        fill_stat_cache_info(ce, &st);
        if (lstat(path, &st) < 0)
                die("unable to stat newly created file %s", path);
        fill_stat_cache_info(ce, &st);

-       if (write_sha1_file(buf, size, "blob", ce->sha1) < 0)
+       if (write_sha1_file(buf, size, blob_type, ce->sha1) < 0)

                die("unable to create backing store for newly created file %s", path);
        if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)
                die("unable to add cache entry for %s", path);
                die("unable to create backing store for newly created file %s", path);
        if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)
                die("unable to add cache entry for %s", path);

diff --git a/blame.c b/blame.c
index 396defccc728db836732aa140e54620775509760..98f99922a78578a84468f1296d6e56b999829659 100644 (file)
--- a/blame.c
+++ b/blame.c
@@ -229,7 +229,7 @@ static void get_blob(struct commit *commit)
 
        info->buf = read_sha1_file(info->sha1, type, &info->size);
 
 
        info->buf = read_sha1_file(info->sha1, type, &info->size);
 

-       assert(!strcmp(type, "blob"));
+       assert(!strcmp(type, blob_type));

 }
 
 /* For debugging only */
 }
 
 /* For debugging only */

diff --git a/cat-file.c b/cat-file.c
index 761111eb0f1f3266fe6bd0e9e561ee3d3d6c21d4..628f6cada89431acd23d612f7e0b10649348e088 100644 (file)
--- a/cat-file.c
+++ b/cat-file.c
@@ -5,6 +5,8 @@
  */
 #include "cache.h"
 #include "exec_cmd.h"
  */
 #include "cache.h"
 #include "exec_cmd.h"

+#include "tag.h"
+#include "tree.h"

 
 static void flush_buffer(const char *buf, unsigned long size)
 {
 
 static void flush_buffer(const char *buf, unsigned long size)
 {


@@ -136,13 +138,13 @@ int main(int argc, char **argv)
                        die("Not a valid object name %s", argv[2]);
 
                /* custom pretty-print here */
                        die("Not a valid object name %s", argv[2]);
 
                /* custom pretty-print here */

-               if (!strcmp(type, "tree"))
+               if (!strcmp(type, tree_type))

                        return execl_git_cmd("ls-tree", argv[2], NULL);
 
                buf = read_sha1_file(sha1, type, &size);
                if (!buf)
                        die("Cannot read object %s", argv[2]);
                        return execl_git_cmd("ls-tree", argv[2], NULL);
 
                buf = read_sha1_file(sha1, type, &size);
                if (!buf)
                        die("Cannot read object %s", argv[2]);

-               if (!strcmp(type, "tag"))
+               if (!strcmp(type, tag_type))

                        return pprint_tag(sha1, buf, size);
 
                /* otherwise just spit out the data */
                        return pprint_tag(sha1, buf, size);
 
                /* otherwise just spit out the data */

diff --git a/combine-diff.c b/combine-diff.c
index f17aab33f1d241097a16e2cfd8a1ab3361e45902..7693884fdb7e43d0aecd77ad1c71531181d7ceee 100644 (file)
--- a/combine-diff.c
+++ b/combine-diff.c
@@ -1,5 +1,6 @@
 #include "cache.h"
 #include "commit.h"
 #include "cache.h"
 #include "commit.h"

+#include "blob.h"

 #include "diff.h"
 #include "diffcore.h"
 #include "quote.h"
 #include "diff.h"
 #include "diffcore.h"
 #include "quote.h"


@@ -104,7 +105,7 @@ static char *grab_blob(const unsigned char *sha1, unsigned long *size)
                return xcalloc(1, 1);
        }
        blob = read_sha1_file(sha1, type, size);
                return xcalloc(1, 1);
        }
        blob = read_sha1_file(sha1, type, size);

-       if (strcmp(type, "blob"))
+       if (strcmp(type, blob_type))

                die("object '%s' is not a blob!", sha1_to_hex(sha1));
        return blob;
 }
                die("object '%s' is not a blob!", sha1_to_hex(sha1));
        return blob;
 }

diff --git a/commit-tree.c b/commit-tree.c
index 16c17871334601b0b3c211cbedd8e8291af261a3..2d8651894a20e752eb47e6da439ad3cee13c29c4 100644 (file)
--- a/commit-tree.c
+++ b/commit-tree.c
@@ -4,6 +4,8 @@
  * Copyright (C) Linus Torvalds, 2005
  */
 #include "cache.h"
  * Copyright (C) Linus Torvalds, 2005
  */
 #include "cache.h"

+#include "commit.h"
+#include "tree.h"

 
 #define BLOCKING (1ul << 14)
 
 
 #define BLOCKING (1ul << 14)
 


@@ -93,13 +95,13 @@ int main(int argc, char **argv)
        if (argc < 2 || get_sha1_hex(argv[1], tree_sha1) < 0)
                usage(commit_tree_usage);
 
        if (argc < 2 || get_sha1_hex(argv[1], tree_sha1) < 0)
                usage(commit_tree_usage);
 

-       check_valid(tree_sha1, "tree");
+       check_valid(tree_sha1, tree_type);

        for (i = 2; i < argc; i += 2) {
                char *a, *b;
                a = argv[i]; b = argv[i+1];
                if (!b || strcmp(a, "-p") || get_sha1(b, parent_sha1[parents]))
                        usage(commit_tree_usage);
        for (i = 2; i < argc; i += 2) {
                char *a, *b;
                a = argv[i]; b = argv[i+1];
                if (!b || strcmp(a, "-p") || get_sha1(b, parent_sha1[parents]))
                        usage(commit_tree_usage);

-               check_valid(parent_sha1[parents], "commit");
+               check_valid(parent_sha1[parents], commit_type);

                if (new_parent(parents))
                        parents++;
        }
                if (new_parent(parents))
                        parents++;
        }


@@ -125,7 +127,7 @@ int main(int argc, char **argv)
        while (fgets(comment, sizeof(comment), stdin) != NULL)
                add_buffer(&buffer, &size, "%s", comment);
 
        while (fgets(comment, sizeof(comment), stdin) != NULL)
                add_buffer(&buffer, &size, "%s", comment);
 

-       if (!write_sha1_file(buffer, size, "commit", commit_sha1)) {
+       if (!write_sha1_file(buffer, size, commit_type, commit_sha1)) {

                printf("%s\n", sha1_to_hex(commit_sha1));
                return 0;
        }
                printf("%s\n", sha1_to_hex(commit_sha1));
                return 0;
        }

diff --git a/convert-objects.c b/convert-objects.c
index b49bce2681caec6cf6ea008aae6d9c58fff60639..57de37faa53df5fb84247e2fd7486a108039676e 100644 (file)
--- a/convert-objects.c
+++ b/convert-objects.c
@@ -2,6 +2,9 @@
 #define _XOPEN_SOURCE_EXTENDED 1 /* AIX 5.3L needs this */
 #include <time.h>
 #include "cache.h"
 #define _XOPEN_SOURCE_EXTENDED 1 /* AIX 5.3L needs this */
 #include <time.h>
 #include "cache.h"

+#include "blob.h"
+#include "commit.h"
+#include "tree.h"

 
 struct entry {
        unsigned char old_sha1[20];
 
 struct entry {
        unsigned char old_sha1[20];


@@ -122,7 +125,7 @@ static int write_subdirectory(void *buffer, unsigned long size, const char *base
                buffer += len;
        }
 
                buffer += len;
        }
 

-       write_sha1_file(new, newlen, "tree", result_sha1);
+       write_sha1_file(new, newlen, tree_type, result_sha1);

        free(new);
        return used;
 }
        free(new);
        return used;
 }


@@ -262,8 +265,8 @@ static void convert_date(void *buffer, unsigned long size, unsigned char *result
        memcpy(new + newlen, buffer, size);
        newlen += size;
 
        memcpy(new + newlen, buffer, size);
        newlen += size;
 

-       write_sha1_file(new, newlen, "commit", result_sha1);
-       free(new);      
+       write_sha1_file(new, newlen, commit_type, result_sha1);
+       free(new);

 }
 
 static void convert_commit(void *buffer, unsigned long size, unsigned char *result_sha1)
 }
 
 static void convert_commit(void *buffer, unsigned long size, unsigned char *result_sha1)


@@ -297,12 +300,12 @@ static struct entry * convert_entry(unsigned char *sha1)
 
        buffer = xmalloc(size);
        memcpy(buffer, data, size);
 
        buffer = xmalloc(size);
        memcpy(buffer, data, size);

-       
-       if (!strcmp(type, "blob")) {
-               write_sha1_file(buffer, size, "blob", entry->new_sha1);
-       } else if (!strcmp(type, "tree"))
+
+       if (!strcmp(type, blob_type)) {
+               write_sha1_file(buffer, size, blob_type, entry->new_sha1);
+       } else if (!strcmp(type, tree_type))

                convert_tree(buffer, size, entry->new_sha1);
                convert_tree(buffer, size, entry->new_sha1);

-       else if (!strcmp(type, "commit"))
+       else if (!strcmp(type, commit_type))

                convert_commit(buffer, size, entry->new_sha1);
        else
                die("unknown object type '%s' in %s", type, sha1_to_hex(sha1));
                convert_commit(buffer, size, entry->new_sha1);
        else
                die("unknown object type '%s' in %s", type, sha1_to_hex(sha1));

diff --git a/diff-tree.c b/diff-tree.c
index f55a35a9d5f9ae4e3f7d3fd778a953cc9cc533ad..d1265d796388dd1c1a56c00f793893ee9dc6ed10 100644 (file)
--- a/diff-tree.c
+++ b/diff-tree.c
@@ -52,7 +52,7 @@ static int diff_root_tree(const unsigned char *new, const char *base)
        void *tree;
        struct tree_desc empty, real;
 
        void *tree;
        struct tree_desc empty, real;
 

-       tree = read_object_with_reference(new, "tree", &real.size, NULL);
+       tree = read_object_with_reference(new, tree_type, &real.size, NULL);

        if (!tree)
                die("unable to read root tree (%s)", sha1_to_hex(new));
        real.buf = tree;
        if (!tree)
                die("unable to read root tree (%s)", sha1_to_hex(new));
        real.buf = tree;

diff --git a/entry.c b/entry.c
index 5d9aefd03fa4ff0e86d1212dc3354c9b50bba22a..793724fd52063157545f523f6d88953b96385c2c 100644 (file)
--- a/entry.c
+++ b/entry.c
@@ -1,6 +1,7 @@
 #include <sys/types.h>
 #include <dirent.h>
 #include "cache.h"
 #include <sys/types.h>
 #include <dirent.h>
 #include "cache.h"

+#include "blob.h"

 
 static void create_directories(const char *path, struct checkout *state)
 {
 
 static void create_directories(const char *path, struct checkout *state)
 {


@@ -72,7 +73,7 @@ static int write_entry(struct cache_entry *ce, char *path, struct checkout *stat
        char type[20];
 
        new = read_sha1_file(ce->sha1, type, &size);
        char type[20];
 
        new = read_sha1_file(ce->sha1, type, &size);

-       if (!new || strcmp(type, "blob")) {
+       if (!new || strcmp(type, blob_type)) {

                if (new)
                        free(new);
                return error("git-checkout-index: unable to read sha1 file of %s (%s)",
                if (new)
                        free(new);
                return error("git-checkout-index: unable to read sha1 file of %s (%s)",

diff --git a/hash-object.c b/hash-object.c
index 6502b5b3d1307a4cd7e8761c96aa7ecd5e70559f..43bd93bffb3f5e0b7b19a62865347a421d6a56a3 100644 (file)
--- a/hash-object.c
+++ b/hash-object.c
@@ -2,9 +2,10 @@
  * GIT - The information manager from hell
  *
  * Copyright (C) Linus Torvalds, 2005
  * GIT - The information manager from hell
  *
  * Copyright (C) Linus Torvalds, 2005

- * Copyright (C) Junio C Hamano, 2005 
+ * Copyright (C) Junio C Hamano, 2005

  */
 #include "cache.h"
  */
 #include "cache.h"

+#include "blob.h"

 
 static void hash_object(const char *path, const char *type, int write_object)
 {
 
 static void hash_object(const char *path, const char *type, int write_object)
 {


@@ -35,7 +36,7 @@ static const char hash_object_usage[] =
 int main(int argc, char **argv)
 {
        int i;
 int main(int argc, char **argv)
 {
        int i;

-       const char *type = "blob";
+       const char *type = blob_type;

        int write_object = 0;
        const char *prefix = NULL;
        int prefix_length = -1;
        int write_object = 0;
        const char *prefix = NULL;
        int prefix_length = -1;

diff --git a/index-pack.c b/index-pack.c
index babe34b2db520a311d6c8ef090383755ba1807c9..b39953dc698aae25f79caa9553e13bca6cd4e986 100644 (file)
--- a/index-pack.c
+++ b/index-pack.c
@@ -2,6 +2,10 @@
 #include "delta.h"
 #include "pack.h"
 #include "csum-file.h"
 #include "delta.h"
 #include "pack.h"
 #include "csum-file.h"

+#include "blob.h"
+#include "commit.h"
+#include "tag.h"
+#include "tree.h"

 
 static const char index_pack_usage[] =
 "git-index-pack [-o index-file] pack-file";
 
 static const char index_pack_usage[] =
 "git-index-pack [-o index-file] pack-file";


@@ -224,10 +228,10 @@ static void sha1_object(const void *data, unsigned long size,
        const char *type_str;
 
        switch (type) {
        const char *type_str;
 
        switch (type) {

-       case OBJ_COMMIT: type_str = "commit"; break;
-       case OBJ_TREE:   type_str = "tree"; break;
-       case OBJ_BLOB:   type_str = "blob"; break;
-       case OBJ_TAG:    type_str = "tag"; break;
+       case OBJ_COMMIT: type_str = commit_type; break;
+       case OBJ_TREE:   type_str = tree_type; break;
+       case OBJ_BLOB:   type_str = blob_type; break;
+       case OBJ_TAG:    type_str = tag_type; break;

        default:
                die("bad type %d", type);
        }
        default:
                die("bad type %d", type);
        }

diff --git a/ls-tree.c b/ls-tree.c
index 26258c3cf99c9eec522ea1a13a2ded3beb93e171..e4ef200985030e8dee6f23dbe723bfa476160db0 100644 (file)
--- a/ls-tree.c
+++ b/ls-tree.c
@@ -56,7 +56,7 @@ static int show_tree(unsigned char *sha1, const char *base, int baselen,
                     const char *pathname, unsigned mode, int stage)
 {
        int retval = 0;
                     const char *pathname, unsigned mode, int stage)
 {
        int retval = 0;

-       const char *type = "blob";
+       const char *type = blob_type;

 
        if (S_ISDIR(mode)) {
                if (show_recursive(base, baselen, pathname)) {
 
        if (S_ISDIR(mode)) {
                if (show_recursive(base, baselen, pathname)) {


@@ -64,7 +64,7 @@ static int show_tree(unsigned char *sha1, const char *base, int baselen,
                        if (!(ls_options & LS_SHOW_TREES))
                                return retval;
                }
                        if (!(ls_options & LS_SHOW_TREES))
                                return retval;
                }

-               type = "tree";
+               type = tree_type;

        }
        else if (ls_options & LS_TREE_ONLY)
                return 0;
        }
        else if (ls_options & LS_TREE_ONLY)
                return 0;

diff --git a/mktag.c b/mktag.c
index fc6a9bf5f34158605add585439848367deaefac5..23288781cf6caad62253130f75112e18eb4905aa 100644 (file)
--- a/mktag.c
+++ b/mktag.c
@@ -1,4 +1,5 @@
 #include "cache.h"
 #include "cache.h"

+#include "tag.h"

 
 /*
  * A signature file has a very simple fixed format: three lines
 
 /*
  * A signature file has a very simple fixed format: three lines


@@ -126,7 +127,7 @@ int main(int argc, char **argv)
        if (verify_tag(buffer, size) < 0)
                die("invalid tag signature file");
 
        if (verify_tag(buffer, size) < 0)
                die("invalid tag signature file");
 

-       if (write_sha1_file(buffer, size, "tag", result_sha1) < 0)
+       if (write_sha1_file(buffer, size, tag_type, result_sha1) < 0)

                die("unable to write tag file");
        printf("%s\n", sha1_to_hex(result_sha1));
        return 0;
                die("unable to write tag file");
        printf("%s\n", sha1_to_hex(result_sha1));
        return 0;

diff --git a/mktree.c b/mktree.c
index f85358522b93d285a13193b44f68c1ebefc101b5..ab63cd99d4ae41310b97811cf738803afe16ff1f 100644 (file)
--- a/mktree.c
+++ b/mktree.c
@@ -6,6 +6,7 @@
 #include "cache.h"
 #include "strbuf.h"
 #include "quote.h"
 #include "cache.h"
 #include "strbuf.h"
 #include "quote.h"

+#include "tree.h"

 
 static struct treeent {
        unsigned mode;
 
 static struct treeent {
        unsigned mode;


@@ -67,7 +68,7 @@ static void write_tree(unsigned char *sha1)
                memcpy(buffer + offset, ent->sha1, 20);
                offset += 20;
        }
                memcpy(buffer + offset, ent->sha1, 20);
                offset += 20;
        }

-       write_sha1_file(buffer, offset, "tree", sha1);
+       write_sha1_file(buffer, offset, tree_type, sha1);

 }
 
 static const char mktree_usage[] = "mktree [-z]";
 }
 
 static const char mktree_usage[] = "mktree [-z]";

diff --git a/object.c b/object.c
index c9ca481498281adab056a364a3854180456f20f3..b5c0ecf2b72bd520ee88b790aa424588178d02d3 100644 (file)
--- a/object.c
+++ b/object.c
@@ -196,15 +196,15 @@ struct object *parse_object(const unsigned char *sha1)
                struct object *obj;
                if (check_sha1_signature(sha1, buffer, size, type) < 0)
                        printf("sha1 mismatch %s\n", sha1_to_hex(sha1));
                struct object *obj;
                if (check_sha1_signature(sha1, buffer, size, type) < 0)
                        printf("sha1 mismatch %s\n", sha1_to_hex(sha1));

-               if (!strcmp(type, "blob")) {
+               if (!strcmp(type, blob_type)) {

                        struct blob *blob = lookup_blob(sha1);
                        parse_blob_buffer(blob, buffer, size);
                        obj = &blob->object;
                        struct blob *blob = lookup_blob(sha1);
                        parse_blob_buffer(blob, buffer, size);
                        obj = &blob->object;

-               } else if (!strcmp(type, "tree")) {
+               } else if (!strcmp(type, tree_type)) {

                        struct tree *tree = lookup_tree(sha1);
                        parse_tree_buffer(tree, buffer, size);
                        obj = &tree->object;
                        struct tree *tree = lookup_tree(sha1);
                        parse_tree_buffer(tree, buffer, size);
                        obj = &tree->object;

-               } else if (!strcmp(type, "commit")) {
+               } else if (!strcmp(type, commit_type)) {

                        struct commit *commit = lookup_commit(sha1);
                        parse_commit_buffer(commit, buffer, size);
                        if (!commit->buffer) {
                        struct commit *commit = lookup_commit(sha1);
                        parse_commit_buffer(commit, buffer, size);
                        if (!commit->buffer) {


@@ -212,7 +212,7 @@ struct object *parse_object(const unsigned char *sha1)
                                buffer = NULL;
                        }
                        obj = &commit->object;
                                buffer = NULL;
                        }
                        obj = &commit->object;

-               } else if (!strcmp(type, "tag")) {
+               } else if (!strcmp(type, tag_type)) {

                        struct tag *tag = lookup_tag(sha1);
                        parse_tag_buffer(tag, buffer, size);
                        obj = &tag->object;
                        struct tag *tag = lookup_tag(sha1);
                        parse_tag_buffer(tag, buffer, size);
                        obj = &tag->object;

diff --git a/pack-objects.c b/pack-objects.c
index ccfaa5f609431490c886abe0e0af842987428bf6..4145f2530501dd80c6ec8a26465bd45f2e258f17 100644 (file)
--- a/pack-objects.c
+++ b/pack-objects.c
@@ -1,5 +1,9 @@
 #include "cache.h"
 #include "object.h"
 #include "cache.h"
 #include "object.h"

+#include "blob.h"
+#include "commit.h"
+#include "tag.h"
+#include "tree.h"

 #include "delta.h"
 #include "pack.h"
 #include "csum-file.h"
 #include "delta.h"
 #include "pack.h"
 #include "csum-file.h"


@@ -603,7 +607,7 @@ static void add_pbase_tree(struct tree_desc *tree, struct name_path *up)
                if (!add_object_entry(sha1, hash, 1))
                        continue;
 
                if (!add_object_entry(sha1, hash, 1))
                        continue;
 

-               if (!strcmp(type, "tree")) {
+               if (!strcmp(type, tree_type)) {

                        struct tree_desc sub;
                        void *elem;
                        struct name_path me;
                        struct tree_desc sub;
                        void *elem;
                        struct name_path me;


@@ -626,7 +630,7 @@ static void add_preferred_base(unsigned char *sha1)
        struct tree_desc tree;
        void *elem;
 
        struct tree_desc tree;
        void *elem;
 

-       elem = read_object_with_reference(sha1, "tree", &tree.size, NULL);
+       elem = read_object_with_reference(sha1, tree_type, &tree.size, NULL);

        tree.buf = elem;
        if (!tree.buf)
                return;
        tree.buf = elem;
        if (!tree.buf)
                return;


@@ -684,13 +688,13 @@ static void check_object(struct object_entry *entry)
                die("unable to get type of object %s",
                    sha1_to_hex(entry->sha1));
 
                die("unable to get type of object %s",
                    sha1_to_hex(entry->sha1));
 

-       if (!strcmp(type, "commit")) {
+       if (!strcmp(type, commit_type)) {

                entry->type = OBJ_COMMIT;
                entry->type = OBJ_COMMIT;

-       } else if (!strcmp(type, "tree")) {
+       } else if (!strcmp(type, tree_type)) {

                entry->type = OBJ_TREE;
                entry->type = OBJ_TREE;

-       } else if (!strcmp(type, "blob")) {
+       } else if (!strcmp(type, blob_type)) {

                entry->type = OBJ_BLOB;
                entry->type = OBJ_BLOB;

-       } else if (!strcmp(type, "tag")) {
+       } else if (!strcmp(type, tag_type)) {

                entry->type = OBJ_TAG;
        } else
                die("unable to pack object %s of type %s",
                entry->type = OBJ_TAG;
        } else
                die("unable to pack object %s of type %s",

diff --git a/revision.c b/revision.c
index 728b6d111dd3e11de6f5a6a0baa940d54d621e6a..ce35b5a7e6960383debb4541c573ecf02d192cae 100644 (file)
--- a/revision.c
+++ b/revision.c
@@ -260,7 +260,7 @@ int rev_same_tree_as_empty(struct tree *t1)
        if (!t1)
                return 0;
 
        if (!t1)
                return 0;
 

-       tree = read_object_with_reference(t1->object.sha1, "tree", &real.size, NULL);
+       tree = read_object_with_reference(t1->object.sha1, tree_type, &real.size, NULL);

        if (!tree)
                return 0;
        real.buf = tree;
        if (!tree)
                return 0;
        real.buf = tree;

diff --git a/sha1_file.c b/sha1_file.c
index 58edec0bb677e480552b9464e905ea983747c183..ba8c4f76011c68548e959a17883b9a9d6cfbeeff 100644 (file)
--- a/sha1_file.c
+++ b/sha1_file.c
@@ -9,6 +9,10 @@
 #include "cache.h"
 #include "delta.h"
 #include "pack.h"
 #include "cache.h"
 #include "delta.h"
 #include "pack.h"

+#include "blob.h"
+#include "commit.h"
+#include "tag.h"
+#include "tree.h"

 
 #ifndef O_NOATIME
 #if defined(__linux__) && (defined(__i386__) || defined(__PPC__))
 
 #ifndef O_NOATIME
 #if defined(__linux__) && (defined(__i386__) || defined(__PPC__))


@@ -894,16 +898,16 @@ void packed_object_info_detail(struct pack_entry *e,
        }
        switch (kind) {
        case OBJ_COMMIT:
        }
        switch (kind) {
        case OBJ_COMMIT:

-               strcpy(type, "commit");
+               strcpy(type, commit_type);

                break;
        case OBJ_TREE:
                break;
        case OBJ_TREE:

-               strcpy(type, "tree");
+               strcpy(type, tree_type);

                break;
        case OBJ_BLOB:
                break;
        case OBJ_BLOB:

-               strcpy(type, "blob");
+               strcpy(type, blob_type);

                break;
        case OBJ_TAG:
                break;
        case OBJ_TAG:

-               strcpy(type, "tag");
+               strcpy(type, tag_type);

                break;
        default:
                die("corrupted pack file %s containing object of kind %d",
                break;
        default:
                die("corrupted pack file %s containing object of kind %d",


@@ -934,16 +938,16 @@ static int packed_object_info(struct pack_entry *entry,
                unuse_packed_git(p);
                return retval;
        case OBJ_COMMIT:
                unuse_packed_git(p);
                return retval;
        case OBJ_COMMIT:

-               strcpy(type, "commit");
+               strcpy(type, commit_type);

                break;
        case OBJ_TREE:
                break;
        case OBJ_TREE:

-               strcpy(type, "tree");
+               strcpy(type, tree_type);

                break;
        case OBJ_BLOB:
                break;
        case OBJ_BLOB:

-               strcpy(type, "blob");
+               strcpy(type, blob_type);

                break;
        case OBJ_TAG:
                break;
        case OBJ_TAG:

-               strcpy(type, "tag");
+               strcpy(type, tag_type);

                break;
        default:
                die("corrupted pack file %s containing object of kind %d",
                break;
        default:
                die("corrupted pack file %s containing object of kind %d",


@@ -1071,16 +1075,16 @@ void *unpack_entry_gently(struct pack_entry *entry,
                retval = unpack_delta_entry(pack, size, left, type, sizep, p);
                return retval;
        case OBJ_COMMIT:
                retval = unpack_delta_entry(pack, size, left, type, sizep, p);
                return retval;
        case OBJ_COMMIT:

-               strcpy(type, "commit");
+               strcpy(type, commit_type);

                break;
        case OBJ_TREE:
                break;
        case OBJ_TREE:

-               strcpy(type, "tree");
+               strcpy(type, tree_type);

                break;
        case OBJ_BLOB:
                break;
        case OBJ_BLOB:

-               strcpy(type, "blob");
+               strcpy(type, blob_type);

                break;
        case OBJ_TAG:
                break;
        case OBJ_TAG:

-               strcpy(type, "tag");
+               strcpy(type, tag_type);

                break;
        default:
                return NULL;
                break;
        default:
                return NULL;


@@ -1241,9 +1245,9 @@ void *read_object_with_reference(const unsigned char *sha1,
                        return buffer;
                }
                /* Handle references */
                        return buffer;
                }
                /* Handle references */

-               else if (!strcmp(type, "commit"))
+               else if (!strcmp(type, commit_type))

                        ref_type = "tree ";
                        ref_type = "tree ";

-               else if (!strcmp(type, "tag"))
+               else if (!strcmp(type, tag_type))

                        ref_type = "object ";
                else {
                        free(buffer);
                        ref_type = "object ";
                else {
                        free(buffer);


@@ -1625,7 +1629,7 @@ int index_pipe(unsigned char *sha1, int fd, const char *type, int write_object)
                return -1;
        }
        if (!type)
                return -1;
        }
        if (!type)

-               type = "blob";
+               type = blob_type;

        if (write_object)
                ret = write_sha1_file(buf, off, type, sha1);
        else {
        if (write_object)
                ret = write_sha1_file(buf, off, type, sha1);
        else {


@@ -1652,7 +1656,7 @@ int index_fd(unsigned char *sha1, int fd, struct stat *st, int write_object, con
                return -1;
 
        if (!type)
                return -1;
 
        if (!type)

-               type = "blob";
+               type = blob_type;

        if (write_object)
                ret = write_sha1_file(buf, size, type, sha1);
        else {
        if (write_object)
                ret = write_sha1_file(buf, size, type, sha1);
        else {


@@ -1690,9 +1694,9 @@ int index_path(unsigned char *sha1, const char *path, struct stat *st, int write
                if (!write_object) {
                        unsigned char hdr[50];
                        int hdrlen;
                if (!write_object) {
                        unsigned char hdr[50];
                        int hdrlen;

-                       write_sha1_file_prepare(target, st->st_size, "blob",
+                       write_sha1_file_prepare(target, st->st_size, blob_type,

                                                sha1, hdr, &hdrlen);
                                                sha1, hdr, &hdrlen);

-               } else if (write_sha1_file(target, st->st_size, "blob", sha1))
+               } else if (write_sha1_file(target, st->st_size, blob_type, sha1))

                        return error("%s: failed to insert into database",
                                     path);
                free(target);
                        return error("%s: failed to insert into database",
                                     path);
                free(target);

diff --git a/tar-tree.c b/tar-tree.c
index bd289a98f80d4a6869f3d7345bd53f16a43682bd..fc60a90873d1928ce3ada6d26f0a0ae571d43773 100644 (file)
--- a/tar-tree.c
+++ b/tar-tree.c
@@ -335,7 +335,7 @@ int main(int argc, char **argv)
        } else
                archive_time = time(NULL);
 
        } else
                archive_time = time(NULL);
 

-       tree.buf = read_object_with_reference(sha1, "tree", &tree.size,
+       tree.buf = read_object_with_reference(sha1, tree_type, &tree.size,

                                              tree_sha1);
        if (!tree.buf)
                die("not a reference to a tag, commit or tree object: %s",
                                              tree_sha1);
        if (!tree.buf)
                die("not a reference to a tag, commit or tree object: %s",

diff --git a/tree-diff.c b/tree-diff.c
index 7bb6109111c0e8d4de11597fd64acb2a8b346879..701fbba65c2d718a2cdff170a6be6d9993ad27d7 100644 (file)
--- a/tree-diff.c
+++ b/tree-diff.c
@@ -3,6 +3,7 @@
  */
 #include "cache.h"
 #include "diff.h"
  */
 #include "cache.h"
 #include "diff.h"

+#include "tree.h"

 
 // What paths are we interested in?
 static int nr_paths = 0;
 
 // What paths are we interested in?
 static int nr_paths = 0;


@@ -148,7 +149,7 @@ static int show_entry(struct diff_options *opt, const char *prefix, struct tree_
                void *tree;
 
                tree = read_sha1_file(sha1, type, &inner.size);
                void *tree;
 
                tree = read_sha1_file(sha1, type, &inner.size);

-               if (!tree || strcmp(type, "tree"))
+               if (!tree || strcmp(type, tree_type))

                        die("corrupt tree sha %s", sha1_to_hex(sha1));
 
                inner.buf = tree;
                        die("corrupt tree sha %s", sha1_to_hex(sha1));
 
                inner.buf = tree;


@@ -206,10 +207,10 @@ int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const cha
        struct tree_desc t1, t2;
        int retval;
 
        struct tree_desc t1, t2;
        int retval;
 

-       tree1 = read_object_with_reference(old, "tree", &t1.size, NULL);
+       tree1 = read_object_with_reference(old, tree_type, &t1.size, NULL);

        if (!tree1)
                die("unable to read source tree (%s)", sha1_to_hex(old));
        if (!tree1)
                die("unable to read source tree (%s)", sha1_to_hex(old));

-       tree2 = read_object_with_reference(new, "tree", &t2.size, NULL);
+       tree2 = read_object_with_reference(new, tree_type, &t2.size, NULL);

        if (!tree2)
                die("unable to read destination tree (%s)", sha1_to_hex(new));
        t1.buf = tree1;
        if (!tree2)
                die("unable to read destination tree (%s)", sha1_to_hex(new));
        t1.buf = tree1;

diff --git a/tree-walk.c b/tree-walk.c
index 0735f4046dd8524e92e97a8ce6cc5c0991208b01..bf8bfdfdf8564d10b0ca5450dc62612e0ae4525d 100644 (file)
--- a/tree-walk.c
+++ b/tree-walk.c
@@ -1,5 +1,6 @@
 #include "cache.h"
 #include "tree-walk.h"
 #include "cache.h"
 #include "tree-walk.h"

+#include "tree.h"

 
 void *fill_tree_descriptor(struct tree_desc *desc, const unsigned char *sha1)
 {
 
 void *fill_tree_descriptor(struct tree_desc *desc, const unsigned char *sha1)
 {


@@ -7,7 +8,7 @@ void *fill_tree_descriptor(struct tree_desc *desc, const unsigned char *sha1)
        void *buf = NULL;
 
        if (sha1) {
        void *buf = NULL;
 
        if (sha1) {

-               buf = read_object_with_reference(sha1, "tree", &size, NULL);
+               buf = read_object_with_reference(sha1, tree_type, &size, NULL);

                if (!buf)
                        die("unable to read tree %s", sha1_to_hex(sha1));
        }
                if (!buf)
                        die("unable to read tree %s", sha1_to_hex(sha1));
        }

diff --git a/unpack-file.c b/unpack-file.c
index 3accb974dd448233a01e82ab1d6e3599d825fa9e..23a85623019c3b7a465fba86132df3f4b75d94a5 100644 (file)
--- a/unpack-file.c
+++ b/unpack-file.c
@@ -1,4 +1,5 @@
 #include "cache.h"
 #include "cache.h"

+#include "blob.h"

 
 static char *create_temp_file(unsigned char *sha1)
 {
 
 static char *create_temp_file(unsigned char *sha1)
 {


@@ -9,7 +10,7 @@ static char *create_temp_file(unsigned char *sha1)
        int fd;
 
        buf = read_sha1_file(sha1, type, &size);
        int fd;
 
        buf = read_sha1_file(sha1, type, &size);

-       if (!buf || strcmp(type, "blob"))
+       if (!buf || strcmp(type, blob_type))

                die("unable to read blob object %s", sha1_to_hex(sha1));
 
        strcpy(path, ".merge_file_XXXXXX");
                die("unable to read blob object %s", sha1_to_hex(sha1));
 
        strcpy(path, ".merge_file_XXXXXX");

diff --git a/unpack-objects.c b/unpack-objects.c
index 815a1b382b1f92686efd00bee5794a8480d7f7b7..3b824b04a262b92808ba138b1922badbbb25da89 100644 (file)
--- a/unpack-objects.c
+++ b/unpack-objects.c
@@ -2,6 +2,10 @@
 #include "object.h"
 #include "delta.h"
 #include "pack.h"
 #include "object.h"
 #include "delta.h"
 #include "pack.h"

+#include "blob.h"
+#include "commit.h"
+#include "tag.h"
+#include "tree.h"

 
 #include <sys/time.h>
 
 
 #include <sys/time.h>
 


@@ -148,10 +152,10 @@ static int unpack_non_delta_entry(enum object_type kind, unsigned long size)
        const char *type;
 
        switch (kind) {
        const char *type;
 
        switch (kind) {

-       case OBJ_COMMIT: type = "commit"; break;
-       case OBJ_TREE:   type = "tree"; break;
-       case OBJ_BLOB:   type = "blob"; break;
-       case OBJ_TAG:    type = "tag"; break;
+       case OBJ_COMMIT: type = commit_type; break;
+       case OBJ_TREE:   type = tree_type; break;
+       case OBJ_BLOB:   type = blob_type; break;
+       case OBJ_TAG:    type = tag_type; break;

        default: die("bad type %d", kind);
        }
        if (!dry_run)
        default: die("bad type %d", kind);
        }
        if (!dry_run)

diff --git a/write-tree.c b/write-tree.c
index addb5de3b6ea5a84ea71293aee5b50f1e70ea720..dcad6e66708f7cf9cae682da6a9a22086381ecec 100644 (file)
--- a/write-tree.c
+++ b/write-tree.c
@@ -4,6 +4,7 @@
  * Copyright (C) Linus Torvalds, 2005
  */
 #include "cache.h"
  * Copyright (C) Linus Torvalds, 2005
  */
 #include "cache.h"

+#include "tree.h"

 
 static int missing_ok = 0;
 
 
 static int missing_ok = 0;
 


@@ -78,7 +79,7 @@ static int write_tree(struct cache_entry **cachep, int maxentries, const char *b
                nr++;
        }
 
                nr++;
        }
 

-       write_sha1_file(buffer, offset, "tree", returnsha1);
+       write_sha1_file(buffer, offset, tree_type, returnsha1);

        free(buffer);
        return nr;
 }
        free(buffer);
        return nr;
 }