Merge branch 'pe/cleanup'

* pe/cleanup:
  Replace xmalloc+memset(0) with xcalloc.
  Use blob_, commit_, tag_, and tree_type throughout.

30 files changed, 120 insertions, 106 deletions

diff --git a/apply.c b/apply.c
index c50b3a6046..33b4271288 100644
--- a/apply.c
+++ b/apply.c
@@ -9,6 +9,7 @@
 #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
@@ -924,8 +925,7 @@ static int parse_single_patch(char *line, unsigned long size, struct patch *patc
 		struct fragment *fragment;
 		int len;
 
-		fragment = xmalloc(sizeof(*fragment));
-		memset(fragment, 0, sizeof(*fragment));
+		fragment = xcalloc(1, sizeof(*fragment));
 		len = parse_fragment(line, size, patch, fragment);
 		if (len <= 0)
 			die("corrupt patch at line %d", linenr);
@@ -1296,7 +1296,7 @@ static int apply_fragments(struct buffer_desc *desc, struct patch *patch)
 			 * 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 "
@@ -1651,15 +1651,14 @@ static void add_index_file(const char *path, unsigned mode, void *buf, unsigned
 	if (!write_index)
 		return;
 
-	ce = xmalloc(ce_size);
-	memset(ce, 0, ce_size);
+	ce = xcalloc(1, ce_size);
 	memcpy(ce->name, path, namelen);
 	ce->ce_mode = create_ce_mode(mode);
 	ce->ce_flags = htons(namelen);
 	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);
@@ -1808,8 +1807,7 @@ static int apply_patch(int fd, const char *filename)
 		struct patch *patch;
 		int nr;
 
-		patch = xmalloc(sizeof(*patch));
-		memset(patch, 0, sizeof(*patch));
+		patch = xcalloc(1, sizeof(*patch));
 		nr = parse_chunk(buffer + offset, size, patch);
 		if (nr < 0)
 			break;
diff --git a/blame.c b/blame.c
index 396defccc7..98f99922a7 100644
--- 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);
 
-	assert(!strcmp(type, "blob"));
+	assert(!strcmp(type, blob_type));
 }
 
 /* For debugging only */
diff --git a/blob.c b/blob.c
index 84ec1212e7..c1fdd861c3 100644
--- a/blob.c
+++ b/blob.c
@@ -8,8 +8,7 @@ struct blob *lookup_blob(const unsigned char *sha1)
 {
 	struct object *obj = lookup_object(sha1);
 	if (!obj) {
-		struct blob *ret = xmalloc(sizeof(struct blob));
-		memset(ret, 0, sizeof(struct blob));
+		struct blob *ret = xcalloc(1, sizeof(struct blob));
 		created_object(sha1, &ret->object);
 		ret->object.type = blob_type;
 		return ret;
diff --git a/cat-file.c b/cat-file.c
index 761111eb0f..628f6cada8 100644
--- a/cat-file.c
+++ b/cat-file.c
@@ -5,6 +5,8 @@
  */
 #include "cache.h"
 #include "exec_cmd.h"
+#include "tag.h"
+#include "tree.h"
 
 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 */
-		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]);
-		if (!strcmp(type, "tag"))
+		if (!strcmp(type, tag_type))
 			return pprint_tag(sha1, buf, size);
 
 		/* otherwise just spit out the data */
diff --git a/combine-diff.c b/combine-diff.c
index f17aab33f1..7693884fdb 100644
--- a/combine-diff.c
+++ b/combine-diff.c
@@ -1,5 +1,6 @@
 #include "cache.h"
 #include "commit.h"
+#include "blob.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);
-	if (strcmp(type, "blob"))
+	if (strcmp(type, blob_type))
 		die("object '%s' is not a blob!", sha1_to_hex(sha1));
 	return blob;
 }
diff --git a/commit-tree.c b/commit-tree.c
index 16c1787133..2d8651894a 100644
--- a/commit-tree.c
+++ b/commit-tree.c
@@ -4,6 +4,8 @@
  * Copyright (C) Linus Torvalds, 2005
  */
 #include "cache.h"
+#include "commit.h"
+#include "tree.h"
 
 #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);
 
-	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);
-		check_valid(parent_sha1[parents], "commit");
+		check_valid(parent_sha1[parents], commit_type);
 		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);
 
-	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;
 	}
diff --git a/commit.c b/commit.c
index eb42d517a4..d4976fb89f 100644
--- a/commit.c
+++ b/commit.c
@@ -73,8 +73,7 @@ struct commit *lookup_commit(const unsigned char *sha1)
 {
 	struct object *obj = lookup_object(sha1);
 	if (!obj) {
-		struct commit *ret = xmalloc(sizeof(struct commit));
-		memset(ret, 0, sizeof(struct commit));
+		struct commit *ret = xcalloc(1, sizeof(struct commit));
 		created_object(sha1, &ret->object);
 		ret->object.type = commit_type;
 		return ret;
diff --git a/convert-objects.c b/convert-objects.c
index b49bce2681..12aacef5a9 100644
--- 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"
+#include "blob.h"
+#include "commit.h"
+#include "tree.h"
 
 struct entry {
 	unsigned char old_sha1[20];
@@ -18,8 +21,7 @@ static struct entry * convert_entry(unsigned char *sha1);
 
 static struct entry *insert_new(unsigned char *sha1, int pos)
 {
-	struct entry *new = xmalloc(sizeof(struct entry));
-	memset(new, 0, sizeof(*new));
+	struct entry *new = xcalloc(1, sizeof(struct entry));
 	memcpy(new->old_sha1, sha1, 20);
 	memmove(convert + pos + 1, convert + pos, (nr_convert - pos) * sizeof(struct entry *));
 	convert[pos] = new;
@@ -122,7 +124,7 @@ static int write_subdirectory(void *buffer, unsigned long size, const char *base
 		buffer += len;
 	}
 
-	write_sha1_file(new, newlen, "tree", result_sha1);
+	write_sha1_file(new, newlen, tree_type, result_sha1);
 	free(new);
 	return used;
 }
@@ -262,8 +264,8 @@ static void convert_date(void *buffer, unsigned long size, unsigned char *result
 	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)
@@ -297,12 +299,12 @@ static struct entry * convert_entry(unsigned char *sha1)
 
 	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);
-	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));
diff --git a/diff-tree.c b/diff-tree.c
index f55a35a9d5..d1265d7963 100644
--- 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;
 
-	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;
diff --git a/entry.c b/entry.c
index 5d9aefd03f..793724fd52 100644
--- a/entry.c
+++ b/entry.c
@@ -1,6 +1,7 @@
 #include <sys/types.h>
 #include <dirent.h>
 #include "cache.h"
+#include "blob.h"
 
 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);
-	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)",
diff --git a/hash-object.c b/hash-object.c
index 6502b5b3d1..43bd93bffb 100644
--- a/hash-object.c
+++ b/hash-object.c
@@ -2,9 +2,10 @@
  * 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 "blob.h"
 
 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;
-	const char *type = "blob";
+	const char *type = blob_type;
 	int write_object = 0;
 	const char *prefix = NULL;
 	int prefix_length = -1;
diff --git a/http-push.c b/http-push.c
index ba7d9de234..b60fa8d241 100644
--- a/http-push.c
+++ b/http-push.c
@@ -1008,8 +1008,7 @@ static int fetch_indices(void)
 	struct active_request_slot *slot;
 	struct slot_results results;
 
-	data = xmalloc(4096);
-	memset(data, 0, 4096);
+	data = xcalloc(1, 4096);
 	buffer.size = 4096;
 	buffer.posn = 0;
 	buffer.buffer = data;
@@ -2042,8 +2041,7 @@ static void update_remote_info_refs(struct remote_lock *lock)
 	char *if_header;
 	struct curl_slist *dav_headers = NULL;
 
-	buffer.buffer = xmalloc(4096);
-	memset(buffer.buffer, 0, 4096);
+	buffer.buffer = xcalloc(1, 4096);
 	buffer.size = 4096;
 	buffer.posn = 0;
 	remote_ls("refs/", (PROCESS_FILES | RECURSIVE),
diff --git a/index-pack.c b/index-pack.c
index babe34b2db..b39953dc69 100644
--- a/index-pack.c
+++ b/index-pack.c
@@ -2,6 +2,10 @@
 #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";
@@ -224,10 +228,10 @@ static void sha1_object(const void *data, unsigned long size,
 	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);
 	}
diff --git a/ls-tree.c b/ls-tree.c
index 26258c3cf9..e4ef200985 100644
--- 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 *type = "blob";
+	const char *type = blob_type;
 
 	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;
 		}
-		type = "tree";
+		type = tree_type;
 	}
 	else if (ls_options & LS_TREE_ONLY)
 		return 0;
diff --git a/mktag.c b/mktag.c
index fc6a9bf5f3..23288781cf 100644
--- a/mktag.c
+++ b/mktag.c
@@ -1,4 +1,5 @@
 #include "cache.h"
+#include "tag.h"
 
 /*
  * 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 (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;
diff --git a/mktree.c b/mktree.c
index f85358522b..ab63cd99d4 100644
--- a/mktree.c
+++ b/mktree.c
@@ -6,6 +6,7 @@
 #include "cache.h"
 #include "strbuf.h"
 #include "quote.h"
+#include "tree.h"
 
 static struct treeent {
 	unsigned mode;
@@ -67,7 +68,7 @@ static void write_tree(unsigned char *sha1)
 		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]";
diff --git a/object.c b/object.c
index c9ca481498..4d46e0d5e4 100644
--- a/object.c
+++ b/object.c
@@ -85,8 +85,7 @@ struct object_refs *alloc_object_refs(unsigned count)
 	struct object_refs *refs;
 	size_t size = sizeof(*refs) + count*sizeof(struct object *);
 
-	refs = xmalloc(size);
-	memset(refs, 0, size);
+	refs = xcalloc(1, size);
 	refs->count = count;
 	return refs;
 }
@@ -178,8 +177,7 @@ struct object *lookup_unknown_object(const unsigned char *sha1)
 {
 	struct object *obj = lookup_object(sha1);
 	if (!obj) {
-		union any_object *ret = xmalloc(sizeof(*ret));
-		memset(ret, 0, sizeof(*ret));
+		union any_object *ret = xcalloc(1, sizeof(*ret));
 		created_object(sha1, &ret->object);
 		ret->object.type = NULL;
 		return &ret->object;
@@ -196,15 +194,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));
-		if (!strcmp(type, "blob")) {
+		if (!strcmp(type, blob_type)) {
 			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;
-		} 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) {
@@ -212,7 +210,7 @@ struct object *parse_object(const unsigned char *sha1)
 				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;
diff --git a/pack-objects.c b/pack-objects.c
index d7ba938af7..9346392150 100644
--- a/pack-objects.c
+++ b/pack-objects.c
@@ -1,5 +1,9 @@
 #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"
@@ -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 (!strcmp(type, "tree")) {
+		if (!strcmp(type, tree_type)) {
 			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;
 
-	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;
@@ -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));
 
-	if (!strcmp(type, "commit")) {
+	if (!strcmp(type, commit_type)) {
 		entry->type = OBJ_COMMIT;
-	} else if (!strcmp(type, "tree")) {
+	} else if (!strcmp(type, tree_type)) {
 		entry->type = OBJ_TREE;
-	} else if (!strcmp(type, "blob")) {
+	} else if (!strcmp(type, blob_type)) {
 		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",
diff --git a/read-tree.c b/read-tree.c
index 4422dbf424..26f4f7e323 100644
--- a/read-tree.c
+++ b/read-tree.c
@@ -133,11 +133,9 @@ static int unpack_trees_rec(struct tree_entry_list **posns, int len,
 		pathlen = strlen(first);
 		ce_size = cache_entry_size(baselen + pathlen);
 
-		src = xmalloc(sizeof(struct cache_entry *) * src_size);
-		memset(src, 0, sizeof(struct cache_entry *) * src_size);
+		src = xcalloc(src_size, sizeof(struct cache_entry *));
 
-		subposns = xmalloc(sizeof(struct tree_list_entry *) * len);
-		memset(subposns, 0, sizeof(struct tree_list_entry *) * len);
+		subposns = xcalloc(len, sizeof(struct tree_list_entry *));
 
 		if (cache_name && !strcmp(cache_name, first)) {
 			any_files = 1;
@@ -177,8 +175,7 @@ static int unpack_trees_rec(struct tree_entry_list **posns, int len,
 			else
 				ce_stage = 2;
 
-			ce = xmalloc(ce_size);
-			memset(ce, 0, ce_size);
+			ce = xcalloc(1, ce_size);
 			ce->ce_mode = create_ce_mode(posns[i]->mode);
 			ce->ce_flags = create_ce_flags(baselen + pathlen,
 						       ce_stage);
diff --git a/revision.c b/revision.c
index 728b6d111d..ce35b5a7e6 100644
--- a/revision.c
+++ b/revision.c
@@ -260,7 +260,7 @@ int rev_same_tree_as_empty(struct tree *t1)
 	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;
diff --git a/sha1_file.c b/sha1_file.c
index 58edec0bb6..ba8c4f7601 100644
--- a/sha1_file.c
+++ b/sha1_file.c
@@ -9,6 +9,10 @@
 #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__))
@@ -894,16 +898,16 @@ void packed_object_info_detail(struct pack_entry *e,
 	}
 	switch (kind) {
 	case OBJ_COMMIT:
-		strcpy(type, "commit");
+		strcpy(type, commit_type);
 		break;
 	case OBJ_TREE:
-		strcpy(type, "tree");
+		strcpy(type, tree_type);
 		break;
 	case OBJ_BLOB:
-		strcpy(type, "blob");
+		strcpy(type, blob_type);
 		break;
 	case OBJ_TAG:
-		strcpy(type, "tag");
+		strcpy(type, tag_type);
 		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:
-		strcpy(type, "commit");
+		strcpy(type, commit_type);
 		break;
 	case OBJ_TREE:
-		strcpy(type, "tree");
+		strcpy(type, tree_type);
 		break;
 	case OBJ_BLOB:
-		strcpy(type, "blob");
+		strcpy(type, blob_type);
 		break;
 	case OBJ_TAG:
-		strcpy(type, "tag");
+		strcpy(type, tag_type);
 		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:
-		strcpy(type, "commit");
+		strcpy(type, commit_type);
 		break;
 	case OBJ_TREE:
-		strcpy(type, "tree");
+		strcpy(type, tree_type);
 		break;
 	case OBJ_BLOB:
-		strcpy(type, "blob");
+		strcpy(type, blob_type);
 		break;
 	case OBJ_TAG:
-		strcpy(type, "tag");
+		strcpy(type, tag_type);
 		break;
 	default:
 		return NULL;
@@ -1241,9 +1245,9 @@ void *read_object_with_reference(const unsigned char *sha1,
 			return buffer;
 		}
 		/* Handle references */
-		else if (!strcmp(type, "commit"))
+		else if (!strcmp(type, commit_type))
 			ref_type = "tree ";
-		else if (!strcmp(type, "tag"))
+		else if (!strcmp(type, tag_type))
 			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)
-		type = "blob";
+		type = blob_type;
 	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)
-		type = "blob";
+		type = blob_type;
 	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;
-			write_sha1_file_prepare(target, st->st_size, "blob",
+			write_sha1_file_prepare(target, st->st_size, blob_type,
 						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);
diff --git a/tag.c b/tag.c
index ac0e57398a..f390ee7030 100644
--- a/tag.c
+++ b/tag.c
@@ -19,8 +19,7 @@ struct tag *lookup_tag(const unsigned char *sha1)
 {
         struct object *obj = lookup_object(sha1);
         if (!obj) {
-                struct tag *ret = xmalloc(sizeof(struct tag));
-                memset(ret, 0, sizeof(struct tag));
+                struct tag *ret = xcalloc(1, sizeof(struct tag));
                 created_object(sha1, &ret->object);
                 ret->object.type = tag_type;
                 return ret;
diff --git a/tar-tree.c b/tar-tree.c
index bd289a98f8..fc60a90873 100644
--- a/tar-tree.c
+++ b/tar-tree.c
@@ -335,7 +335,7 @@ int main(int argc, char **argv)
 	} 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",
diff --git a/tree-diff.c b/tree-diff.c
index 7bb6109111..701fbba65c 100644
--- a/tree-diff.c
+++ b/tree-diff.c
@@ -3,6 +3,7 @@
  */
 #include "cache.h"
 #include "diff.h"
+#include "tree.h"
 
 // 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);
-		if (!tree || strcmp(type, "tree"))
+		if (!tree || strcmp(type, tree_type))
 			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;
 
-	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));
-	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;
diff --git a/tree-walk.c b/tree-walk.c
index 0735f4046d..bf8bfdfdf8 100644
--- a/tree-walk.c
+++ b/tree-walk.c
@@ -1,5 +1,6 @@
 #include "cache.h"
 #include "tree-walk.h"
+#include "tree.h"
 
 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) {
-		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));
 	}
diff --git a/tree.c b/tree.c
index 87e0d743f8..d599fb5e1a 100644
--- a/tree.c
+++ b/tree.c
@@ -18,9 +18,7 @@ static int read_one_entry(unsigned char *sha1, const char *base, int baselen, co
 
 	len = strlen(pathname);
 	size = cache_entry_size(baselen + len);
-	ce = xmalloc(size);
-
-	memset(ce, 0, size);
+	ce = xcalloc(1, size);
 
 	ce->ce_mode = create_ce_mode(mode);
 	ce->ce_flags = create_ce_flags(baselen + len, stage);
@@ -130,8 +128,7 @@ struct tree *lookup_tree(const unsigned char *sha1)
 {
 	struct object *obj = lookup_object(sha1);
 	if (!obj) {
-		struct tree *ret = xmalloc(sizeof(struct tree));
-		memset(ret, 0, sizeof(struct tree));
+		struct tree *ret = xcalloc(1, sizeof(struct tree));
 		created_object(sha1, &ret->object);
 		ret->object.type = tree_type;
 		return ret;
diff --git a/unpack-file.c b/unpack-file.c
index 3accb974dd..23a8562301 100644
--- a/unpack-file.c
+++ b/unpack-file.c
@@ -1,4 +1,5 @@
 #include "cache.h"
+#include "blob.h"
 
 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);
-	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");
diff --git a/unpack-objects.c b/unpack-objects.c
index 815a1b382b..3b824b04a2 100644
--- a/unpack-objects.c
+++ b/unpack-objects.c
@@ -2,6 +2,10 @@
 #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>
 
@@ -148,10 +152,10 @@ static int unpack_non_delta_entry(enum object_type kind, unsigned long size)
 	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)
diff --git a/update-index.c b/update-index.c
index 797245ab27..1efac27c6b 100644
--- a/update-index.c
+++ b/update-index.c
@@ -114,8 +114,7 @@ static int add_file_to_cache(const char *path)
 
 	namelen = strlen(path);
 	size = cache_entry_size(namelen);
-	ce = xmalloc(size);
-	memset(ce, 0, size);
+	ce = xcalloc(1, size);
 	memcpy(ce->name, path, namelen);
 	ce->ce_flags = htons(namelen);
 	fill_stat_cache_info(ce, &st);
@@ -312,8 +311,7 @@ static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,
 
 	len = strlen(path);
 	size = cache_entry_size(len);
-	ce = xmalloc(size);
-	memset(ce, 0, size);
+	ce = xcalloc(1, size);
 
 	memcpy(ce->sha1, sha1, 20);
 	memcpy(ce->name, path, len);
diff --git a/write-tree.c b/write-tree.c
index addb5de3b6..dcad6e6670 100644
--- a/write-tree.c
+++ b/write-tree.c
@@ -4,6 +4,7 @@
  * Copyright (C) Linus Torvalds, 2005
  */
 #include "cache.h"
+#include "tree.h"
 
 static int missing_ok = 0;
 
@@ -78,7 +79,7 @@ static int write_tree(struct cache_entry **cachep, int maxentries, const char *b
 		nr++;
 	}
 
-	write_sha1_file(buffer, offset, "tree", returnsha1);
+	write_sha1_file(buffer, offset, tree_type, returnsha1);
 	free(buffer);
 	return nr;
 }