reachable.c 6.22 KB
Newer Older
1 2 3 4 5 6 7 8 9
#include "cache.h"
#include "refs.h"
#include "tag.h"
#include "commit.h"
#include "blob.h"
#include "diff.h"
#include "revision.h"
#include "reachable.h"
#include "cache-tree.h"
10
#include "progress.h"
11

Jeff King's avatar
Jeff King committed
12 13 14 15 16 17 18 19 20 21 22 23
struct connectivity_progress {
	struct progress *progress;
	unsigned long count;
};

static void update_progress(struct connectivity_progress *cp)
{
	cp->count++;
	if ((cp->count & 1023) == 0)
		display_progress(cp->progress, cp->count);
}

24 25 26
static void process_blob(struct blob *blob,
			 struct object_array *p,
			 struct name_path *path,
Jeff King's avatar
Jeff King committed
27 28
			 const char *name,
			 struct connectivity_progress *cp)
29 30 31
{
	struct object *obj = &blob->object;

32 33
	if (!blob)
		die("bad blob object");
34 35 36
	if (obj->flags & SEEN)
		return;
	obj->flags |= SEEN;
Jeff King's avatar
Jeff King committed
37
	update_progress(cp);
38 39 40
	/* Nothing to do, really .. The blob lookup was the important part */
}

41 42 43 44 45 46 47 48
static void process_gitlink(const unsigned char *sha1,
			    struct object_array *p,
			    struct name_path *path,
			    const char *name)
{
	/* I don't think we want to recurse into this, really. */
}

49 50 51
static void process_tree(struct tree *tree,
			 struct object_array *p,
			 struct name_path *path,
Jeff King's avatar
Jeff King committed
52 53
			 const char *name,
			 struct connectivity_progress *cp)
54 55 56 57 58 59
{
	struct object *obj = &tree->object;
	struct tree_desc desc;
	struct name_entry entry;
	struct name_path me;

60 61
	if (!tree)
		die("bad tree object");
62 63 64
	if (obj->flags & SEEN)
		return;
	obj->flags |= SEEN;
Jeff King's avatar
Jeff King committed
65
	update_progress(cp);
66 67 68 69 70 71 72
	if (parse_tree(tree) < 0)
		die("bad tree object %s", sha1_to_hex(obj->sha1));
	add_object(obj, p, path, name);
	me.up = path;
	me.elem = name;
	me.elem_len = strlen(name);

73
	init_tree_desc(&desc, tree->buffer, tree->size);
74 75 76

	while (tree_entry(&desc, &entry)) {
		if (S_ISDIR(entry.mode))
Jeff King's avatar
Jeff King committed
77
			process_tree(lookup_tree(entry.sha1), p, &me, entry.path, cp);
Junio C Hamano's avatar
Junio C Hamano committed
78
		else if (S_ISGITLINK(entry.mode))
79
			process_gitlink(entry.sha1, p, &me, entry.path);
80
		else
Jeff King's avatar
Jeff King committed
81
			process_blob(lookup_blob(entry.sha1), p, &me, entry.path, cp);
82
	}
83
	free_tree_buffer(tree);
84 85
}

Jeff King's avatar
Jeff King committed
86 87
static void process_tag(struct tag *tag, struct object_array *p,
			const char *name, struct connectivity_progress *cp)
88 89 90 91 92 93
{
	struct object *obj = &tag->object;

	if (obj->flags & SEEN)
		return;
	obj->flags |= SEEN;
Jeff King's avatar
Jeff King committed
94
	update_progress(cp);
95 96 97

	if (parse_tag(tag) < 0)
		die("bad tag object %s", sha1_to_hex(obj->sha1));
98 99
	if (tag->tagged)
		add_object(tag->tagged, p, NULL, name);
100 101
}

Jeff King's avatar
Jeff King committed
102 103
static void walk_commit_list(struct rev_info *revs,
			     struct connectivity_progress *cp)
104 105 106
{
	int i;
	struct commit *commit;
107
	struct object_array objects = OBJECT_ARRAY_INIT;
108 109

	/* Walk all commits, process their trees */
110
	while ((commit = get_revision(revs)) != NULL) {
Jeff King's avatar
Jeff King committed
111 112
		process_tree(commit->tree, &objects, NULL, "", cp);
		update_progress(cp);
113
	}
114 115 116 117 118 119 120

	/* Then walk all the pending objects, recursively processing them too */
	for (i = 0; i < revs->pending.nr; i++) {
		struct object_array_entry *pending = revs->pending.objects + i;
		struct object *obj = pending->item;
		const char *name = pending->name;
		if (obj->type == OBJ_TAG) {
Jeff King's avatar
Jeff King committed
121
			process_tag((struct tag *) obj, &objects, name, cp);
122 123 124
			continue;
		}
		if (obj->type == OBJ_TREE) {
Jeff King's avatar
Jeff King committed
125
			process_tree((struct tree *)obj, &objects, NULL, name, cp);
126 127 128
			continue;
		}
		if (obj->type == OBJ_BLOB) {
Jeff King's avatar
Jeff King committed
129
			process_blob((struct blob *)obj, &objects, NULL, name, cp);
130 131 132 133 134 135
			continue;
		}
		die("unknown pending object %s (%s)", sha1_to_hex(obj->sha1), name);
	}
}

136 137 138
static int add_one_reflog_ent(unsigned char *osha1, unsigned char *nsha1,
		const char *email, unsigned long timestamp, int tz,
		const char *message, void *cb_data)
139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
{
	struct object *object;
	struct rev_info *revs = (struct rev_info *)cb_data;

	object = parse_object(osha1);
	if (object)
		add_pending_object(revs, object, "");
	object = parse_object(nsha1);
	if (object)
		add_pending_object(revs, object, "");
	return 0;
}

static int add_one_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
{
154
	struct object *object = parse_object_or_die(sha1, path);
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
	struct rev_info *revs = (struct rev_info *)cb_data;

	add_pending_object(revs, object, "");

	return 0;
}

static int add_one_reflog(const char *path, const unsigned char *sha1, int flag, void *cb_data)
{
	for_each_reflog_ent(path, add_one_reflog_ent, cb_data);
	return 0;
}

static void add_one_tree(const unsigned char *sha1, struct rev_info *revs)
{
	struct tree *tree = lookup_tree(sha1);
171 172
	if (tree)
		add_pending_object(revs, &tree->object, "");
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
}

static void add_cache_tree(struct cache_tree *it, struct rev_info *revs)
{
	int i;

	if (it->entry_count >= 0)
		add_one_tree(it->sha1, revs);
	for (i = 0; i < it->subtree_nr; i++)
		add_cache_tree(it->down[i]->cache_tree, revs);
}

static void add_cache_refs(struct rev_info *revs)
{
	int i;

	read_cache();
	for (i = 0; i < active_nr; i++) {
191 192 193 194 195 196 197
		/*
		 * The index can contain blobs and GITLINKs, GITLINKs are hashes
		 * that don't actually point to objects in the repository, it's
		 * almost guaranteed that they are NOT blobs, so we don't call
		 * lookup_blob() on them, to avoid populating the hash table
		 * with invalid information
		 */
198
		if (S_ISGITLINK(active_cache[i]->ce_mode))
199 200
			continue;

201 202 203 204 205 206 207 208 209 210 211 212
		lookup_blob(active_cache[i]->sha1);
		/*
		 * We could add the blobs to the pending list, but quite
		 * frankly, we don't care. Once we've looked them up, and
		 * added them as objects, we've really done everything
		 * there is to do for a blob
		 */
	}
	if (active_cache_tree)
		add_cache_tree(active_cache_tree, revs);
}

213 214
void mark_reachable_objects(struct rev_info *revs, int mark_reflog,
			    struct progress *progress)
215
{
Jeff King's avatar
Jeff King committed
216 217
	struct connectivity_progress cp;

218 219 220 221 222 223 224 225 226 227 228 229 230 231
	/*
	 * Set up revision parsing, and mark us as being interested
	 * in all object types, not just commits.
	 */
	revs->tag_objects = 1;
	revs->blob_objects = 1;
	revs->tree_objects = 1;

	/* Add all refs from the index file */
	add_cache_refs(revs);

	/* Add all external refs */
	for_each_ref(add_one_ref, revs);

232 233 234
	/* detached HEAD is not included in the list above */
	head_ref(add_one_ref, revs);

235
	/* Add all reflog info */
236
	if (mark_reflog)
237
		for_each_reflog(add_one_reflog, revs);
238

Jeff King's avatar
Jeff King committed
239 240 241
	cp.progress = progress;
	cp.count = 0;

242 243 244 245
	/*
	 * Set up the revision walk - this will move all commits
	 * from the pending list to the commit walking list.
	 */
246 247
	if (prepare_revision_walk(revs))
		die("revision walk setup failed");
Jeff King's avatar
Jeff King committed
248 249
	walk_commit_list(revs, &cp);
	display_progress(cp.progress, cp.count);
250
}