git

1
#define USE_THE_REPOSITORY_VARIABLE
2

3
#include "git-compat-util.h"
4
#include "hex.h"
5
#include "tree.h"
6
#include "object-name.h"
7
#include "object-store-ll.h"
8
#include "commit.h"
9
#include "alloc.h"
10
#include "tree-walk.h"
11
#include "repository.h"
12
#include "environment.h"
13

14
const char *tree_type = "tree";
15

16
int read_tree_at(struct repository *r,
17
		 struct tree *tree, struct strbuf *base,
18
		 int depth,
19
		 const struct pathspec *pathspec,
20
		 read_tree_fn_t fn, void *context)
21
{
22
	struct tree_desc desc;
23
	struct name_entry entry;
24
	struct object_id oid;
25
	int len, oldlen = base->len;
26
	enum interesting retval = entry_not_interesting;
27

28
	if (depth > max_allowed_tree_depth)
29
		return error("exceeded maximum allowed tree depth");
30

31
	if (parse_tree(tree))
32
		return -1;
33

34
	init_tree_desc(&desc, &tree->object.oid, tree->buffer, tree->size);
35

36
	while (tree_entry(&desc, &entry)) {
37
		if (retval != all_entries_interesting) {
38
			retval = tree_entry_interesting(r->index, &entry,
39
							base, pathspec);
40
			if (retval == all_entries_not_interesting)
41
				break;
42
			if (retval == entry_not_interesting)
43
				continue;
44
		}
45

46
		switch (fn(&entry.oid, base,
47
			   entry.path, entry.mode, context)) {
48
		case 0:
49
			continue;
50
		case READ_TREE_RECURSIVE:
51
			break;
52
		default:
53
			return -1;
54
		}
55

56
		if (S_ISDIR(entry.mode))
57
			oidcpy(&oid, &entry.oid);
58
		else if (S_ISGITLINK(entry.mode)) {
59
			struct commit *commit;
60

61
			commit = lookup_commit(r, &entry.oid);
62
			if (!commit)
63
				die("Commit %s in submodule path %s%s not found",
64
				    oid_to_hex(&entry.oid),
65
				    base->buf, entry.path);
66

67
			if (repo_parse_commit(r, commit))
68
				die("Invalid commit %s in submodule path %s%s",
69
				    oid_to_hex(&entry.oid),
70
				    base->buf, entry.path);
71

72
			oidcpy(&oid, get_commit_tree_oid(commit));
73
		}
74
		else
75
			continue;
76

77
		len = tree_entry_len(&entry);
78
		strbuf_add(base, entry.path, len);
79
		strbuf_addch(base, '/');
80
		retval = read_tree_at(r, lookup_tree(r, &oid),
81
				      base, depth + 1, pathspec,
82
				      fn, context);
83
		strbuf_setlen(base, oldlen);
84
		if (retval)
85
			return -1;
86
	}
87
	return 0;
88
}
89

90
int read_tree(struct repository *r,
91
	      struct tree *tree,
92
	      const struct pathspec *pathspec,
93
	      read_tree_fn_t fn, void *context)
94
{
95
	struct strbuf sb = STRBUF_INIT;
96
	int ret = read_tree_at(r, tree, &sb, 0, pathspec, fn, context);
97
	strbuf_release(&sb);
98
	return ret;
99
}
100

101
int base_name_compare(const char *name1, size_t len1, int mode1,
102
		      const char *name2, size_t len2, int mode2)
103
{
104
	unsigned char c1, c2;
105
	size_t len = len1 < len2 ? len1 : len2;
106
	int cmp;
107

108
	cmp = memcmp(name1, name2, len);
109
	if (cmp)
110
		return cmp;
111
	c1 = name1[len];
112
	c2 = name2[len];
113
	if (!c1 && S_ISDIR(mode1))
114
		c1 = '/';
115
	if (!c2 && S_ISDIR(mode2))
116
		c2 = '/';
117
	return (c1 < c2) ? -1 : (c1 > c2) ? 1 : 0;
118
}
119

120
/*
121
 * df_name_compare() is identical to base_name_compare(), except it
122
 * compares conflicting directory/file entries as equal. Note that
123
 * while a directory name compares as equal to a regular file, they
124
 * then individually compare _differently_ to a filename that has
125
 * a dot after the basename (because '\0' < '.' < '/').
126
 *
127
 * This is used by routines that want to traverse the git namespace
128
 * but then handle conflicting entries together when possible.
129
 */
130
int df_name_compare(const char *name1, size_t len1, int mode1,
131
		    const char *name2, size_t len2, int mode2)
132
{
133
	unsigned char c1, c2;
134
	size_t len = len1 < len2 ? len1 : len2;
135
	int cmp;
136

137
	cmp = memcmp(name1, name2, len);
138
	if (cmp)
139
		return cmp;
140
	/* Directories and files compare equal (same length, same name) */
141
	if (len1 == len2)
142
		return 0;
143
	c1 = name1[len];
144
	if (!c1 && S_ISDIR(mode1))
145
		c1 = '/';
146
	c2 = name2[len];
147
	if (!c2 && S_ISDIR(mode2))
148
		c2 = '/';
149
	if (c1 == '/' && !c2)
150
		return 0;
151
	if (c2 == '/' && !c1)
152
		return 0;
153
	return c1 - c2;
154
}
155

156
int name_compare(const char *name1, size_t len1, const char *name2, size_t len2)
157
{
158
	size_t min_len = (len1 < len2) ? len1 : len2;
159
	int cmp = memcmp(name1, name2, min_len);
160
	if (cmp)
161
		return cmp;
162
	if (len1 < len2)
163
		return -1;
164
	if (len1 > len2)
165
		return 1;
166
	return 0;
167
}
168

169
struct tree *lookup_tree(struct repository *r, const struct object_id *oid)
170
{
171
	struct object *obj = lookup_object(r, oid);
172
	if (!obj)
173
		return create_object(r, oid, alloc_tree_node(r));
174
	return object_as_type(obj, OBJ_TREE, 0);
175
}
176

177
int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
178
{
179
	if (item->object.parsed)
180
		return 0;
181
	item->object.parsed = 1;
182
	item->buffer = buffer;
183
	item->size = size;
184

185
	return 0;
186
}
187

188
int parse_tree_gently(struct tree *item, int quiet_on_missing)
189
{
190
	 enum object_type type;
191
	 void *buffer;
192
	 unsigned long size;
193

194
	if (item->object.parsed)
195
		return 0;
196
	buffer = repo_read_object_file(the_repository, &item->object.oid,
197
				       &type, &size);
198
	if (!buffer)
199
		return quiet_on_missing ? -1 :
200
			error("Could not read %s",
201
			     oid_to_hex(&item->object.oid));
202
	if (type != OBJ_TREE) {
203
		free(buffer);
204
		return error("Object %s not a tree",
205
			     oid_to_hex(&item->object.oid));
206
	}
207
	return parse_tree_buffer(item, buffer, size);
208
}
209

210
void free_tree_buffer(struct tree *tree)
211
{
212
	FREE_AND_NULL(tree->buffer);
213
	tree->size = 0;
214
	tree->object.parsed = 0;
215
}
216

217
struct tree *parse_tree_indirect(const struct object_id *oid)
218
{
219
	struct repository *r = the_repository;
220
	struct object *obj = parse_object(r, oid);
221
	return (struct tree *)repo_peel_to_type(r, NULL, 0, obj, OBJ_TREE);
222
}
223