]>
Commit | Line | Data |
---|---|---|
8f1d2e6f | 1 | #include "cache.h" |
af3785dc | 2 | #include "cache-tree.h" |
175785e5 DB |
3 | #include "tree.h" |
4 | #include "blob.h" | |
77675e2a DB |
5 | #include "commit.h" |
6 | #include "tag.h" | |
136f2e54 | 7 | #include "tree-walk.h" |
175785e5 DB |
8 | |
9 | const char *tree_type = "tree"; | |
10 | ||
af3785dc | 11 | static int read_one_entry_opt(const unsigned char *sha1, const char *base, int baselen, const char *pathname, unsigned mode, int stage, int opt) |
94537c78 | 12 | { |
3c5e8468 LT |
13 | int len; |
14 | unsigned int size; | |
15 | struct cache_entry *ce; | |
16 | ||
17 | if (S_ISDIR(mode)) | |
18 | return READ_TREE_RECURSIVE; | |
19 | ||
20 | len = strlen(pathname); | |
21 | size = cache_entry_size(baselen + len); | |
90321c10 | 22 | ce = xcalloc(1, size); |
94537c78 LT |
23 | |
24 | ce->ce_mode = create_ce_mode(mode); | |
b60e188c TG |
25 | ce->ce_flags = create_ce_flags(stage); |
26 | ce->ce_namelen = baselen + len; | |
94537c78 LT |
27 | memcpy(ce->name, base, baselen); |
28 | memcpy(ce->name + baselen, pathname, len+1); | |
e702496e | 29 | hashcpy(ce->sha1, sha1); |
af3785dc JH |
30 | return add_cache_entry(ce, opt); |
31 | } | |
32 | ||
671f0707 | 33 | static int read_one_entry(const unsigned char *sha1, const char *base, int baselen, const char *pathname, unsigned mode, int stage, void *context) |
af3785dc JH |
34 | { |
35 | return read_one_entry_opt(sha1, base, baselen, pathname, mode, stage, | |
36 | ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK); | |
37 | } | |
38 | ||
39 | /* | |
40 | * This is used when the caller knows there is no existing entries at | |
41 | * the stage that will conflict with the entry being added. | |
42 | */ | |
671f0707 | 43 | static int read_one_entry_quick(const unsigned char *sha1, const char *base, int baselen, const char *pathname, unsigned mode, int stage, void *context) |
af3785dc JH |
44 | { |
45 | return read_one_entry_opt(sha1, base, baselen, pathname, mode, stage, | |
46 | ADD_CACHE_JUST_APPEND); | |
94537c78 LT |
47 | } |
48 | ||
ffd31f66 | 49 | static int read_tree_1(struct tree *tree, struct strbuf *base, |
18e4f405 | 50 | int stage, const struct pathspec *pathspec, |
ffd31f66 | 51 | read_tree_fn_t fn, void *context) |
94537c78 | 52 | { |
0790a42a | 53 | struct tree_desc desc; |
4c068a98 | 54 | struct name_entry entry; |
ffd31f66 | 55 | unsigned char sha1[20]; |
d688cf07 NTND |
56 | int len, oldlen = base->len; |
57 | enum interesting retval = entry_not_interesting; | |
0790a42a | 58 | |
521698b1 DB |
59 | if (parse_tree(tree)) |
60 | return -1; | |
0790a42a | 61 | |
6fda5e51 | 62 | init_tree_desc(&desc, tree->buffer, tree->size); |
0790a42a | 63 | |
4c068a98 | 64 | while (tree_entry(&desc, &entry)) { |
d688cf07 | 65 | if (retval != all_entries_interesting) { |
ffd31f66 | 66 | retval = tree_entry_interesting(&entry, base, 0, pathspec); |
d688cf07 | 67 | if (retval == all_entries_not_interesting) |
ffd31f66 | 68 | break; |
d688cf07 | 69 | if (retval == entry_not_interesting) |
ffd31f66 NTND |
70 | continue; |
71 | } | |
0ca14a57 | 72 | |
ffd31f66 NTND |
73 | switch (fn(entry.sha1, base->buf, base->len, |
74 | entry.path, entry.mode, stage, context)) { | |
3c5e8468 LT |
75 | case 0: |
76 | continue; | |
77 | case READ_TREE_RECURSIVE: | |
ba19a808 | 78 | break; |
3c5e8468 LT |
79 | default: |
80 | return -1; | |
81 | } | |
d3bee161 | 82 | |
ffd31f66 NTND |
83 | if (S_ISDIR(entry.mode)) |
84 | hashcpy(sha1, entry.sha1); | |
85 | else if (S_ISGITLINK(entry.mode)) { | |
86 | struct commit *commit; | |
d3bee161 LH |
87 | |
88 | commit = lookup_commit(entry.sha1); | |
89 | if (!commit) | |
ffd31f66 NTND |
90 | die("Commit %s in submodule path %s%s not found", |
91 | sha1_to_hex(entry.sha1), | |
92 | base->buf, entry.path); | |
d3bee161 LH |
93 | |
94 | if (parse_commit(commit)) | |
ffd31f66 NTND |
95 | die("Invalid commit %s in submodule path %s%s", |
96 | sha1_to_hex(entry.sha1), | |
97 | base->buf, entry.path); | |
98 | ||
99 | hashcpy(sha1, commit->tree->object.sha1); | |
94537c78 | 100 | } |
ffd31f66 NTND |
101 | else |
102 | continue; | |
103 | ||
0de16337 | 104 | len = tree_entry_len(&entry); |
ffd31f66 NTND |
105 | strbuf_add(base, entry.path, len); |
106 | strbuf_addch(base, '/'); | |
107 | retval = read_tree_1(lookup_tree(sha1), | |
108 | base, stage, pathspec, | |
109 | fn, context); | |
110 | strbuf_setlen(base, oldlen); | |
111 | if (retval) | |
112 | return -1; | |
94537c78 LT |
113 | } |
114 | return 0; | |
115 | } | |
116 | ||
ffd31f66 NTND |
117 | int read_tree_recursive(struct tree *tree, |
118 | const char *base, int baselen, | |
18e4f405 | 119 | int stage, const struct pathspec *pathspec, |
ffd31f66 NTND |
120 | read_tree_fn_t fn, void *context) |
121 | { | |
122 | struct strbuf sb = STRBUF_INIT; | |
f0096c06 | 123 | int ret; |
ffd31f66 | 124 | |
ffd31f66 | 125 | strbuf_add(&sb, base, baselen); |
f0096c06 | 126 | ret = read_tree_1(tree, &sb, stage, pathspec, fn, context); |
ffd31f66 | 127 | strbuf_release(&sb); |
ffd31f66 NTND |
128 | return ret; |
129 | } | |
130 | ||
af3785dc JH |
131 | static int cmp_cache_name_compare(const void *a_, const void *b_) |
132 | { | |
133 | const struct cache_entry *ce1, *ce2; | |
134 | ||
135 | ce1 = *((const struct cache_entry **)a_); | |
136 | ce2 = *((const struct cache_entry **)b_); | |
b60e188c TG |
137 | return cache_name_stage_compare(ce1->name, ce1->ce_namelen, ce_stage(ce1), |
138 | ce2->name, ce2->ce_namelen, ce_stage(ce2)); | |
af3785dc JH |
139 | } |
140 | ||
f0096c06 | 141 | int read_tree(struct tree *tree, int stage, struct pathspec *match) |
94537c78 | 142 | { |
af3785dc JH |
143 | read_tree_fn_t fn = NULL; |
144 | int i, err; | |
145 | ||
146 | /* | |
147 | * Currently the only existing callers of this function all | |
148 | * call it with stage=1 and after making sure there is nothing | |
149 | * at that stage; we could always use read_one_entry_quick(). | |
150 | * | |
151 | * But when we decide to straighten out git-read-tree not to | |
152 | * use unpack_trees() in some cases, this will probably start | |
153 | * to matter. | |
154 | */ | |
155 | ||
156 | /* | |
157 | * See if we have cache entry at the stage. If so, | |
158 | * do it the original slow way, otherwise, append and then | |
159 | * sort at the end. | |
160 | */ | |
161 | for (i = 0; !fn && i < active_nr; i++) { | |
9c5e6c80 | 162 | const struct cache_entry *ce = active_cache[i]; |
af3785dc JH |
163 | if (ce_stage(ce) == stage) |
164 | fn = read_one_entry; | |
165 | } | |
166 | ||
167 | if (!fn) | |
168 | fn = read_one_entry_quick; | |
671f0707 | 169 | err = read_tree_recursive(tree, "", 0, stage, match, fn, NULL); |
af3785dc JH |
170 | if (fn == read_one_entry || err) |
171 | return err; | |
172 | ||
173 | /* | |
174 | * Sort the cache entry -- we need to nuke the cache tree, though. | |
175 | */ | |
176 | cache_tree_free(&active_cache_tree); | |
177 | qsort(active_cache, active_nr, sizeof(active_cache[0]), | |
178 | cmp_cache_name_compare); | |
179 | return 0; | |
94537c78 LT |
180 | } |
181 | ||
5d6ccf5c | 182 | struct tree *lookup_tree(const unsigned char *sha1) |
175785e5 DB |
183 | { |
184 | struct object *obj = lookup_object(sha1); | |
100c5f3b LT |
185 | if (!obj) |
186 | return create_object(sha1, OBJ_TREE, alloc_tree_node()); | |
d1af002d | 187 | if (!obj->type) |
1974632c LT |
188 | obj->type = OBJ_TREE; |
189 | if (obj->type != OBJ_TREE) { | |
885a86ab LT |
190 | error("Object %s is a %s, not a tree", |
191 | sha1_to_hex(sha1), typename(obj->type)); | |
175785e5 DB |
192 | return NULL; |
193 | } | |
194 | return (struct tree *) obj; | |
195 | } | |
196 | ||
2d9c58c6 LT |
197 | int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size) |
198 | { | |
175785e5 DB |
199 | if (item->object.parsed) |
200 | return 0; | |
201 | item->object.parsed = 1; | |
136f2e54 LT |
202 | item->buffer = buffer; |
203 | item->size = size; | |
204 | ||
2d9c58c6 LT |
205 | return 0; |
206 | } | |
207 | ||
bd2c39f5 NP |
208 | int parse_tree(struct tree *item) |
209 | { | |
21666f1a | 210 | enum object_type type; |
bd2c39f5 NP |
211 | void *buffer; |
212 | unsigned long size; | |
bd2c39f5 NP |
213 | |
214 | if (item->object.parsed) | |
215 | return 0; | |
21666f1a | 216 | buffer = read_sha1_file(item->object.sha1, &type, &size); |
bd2c39f5 NP |
217 | if (!buffer) |
218 | return error("Could not read %s", | |
219 | sha1_to_hex(item->object.sha1)); | |
21666f1a | 220 | if (type != OBJ_TREE) { |
bd2c39f5 NP |
221 | free(buffer); |
222 | return error("Object %s not a tree", | |
223 | sha1_to_hex(item->object.sha1)); | |
224 | } | |
136f2e54 | 225 | return parse_tree_buffer(item, buffer, size); |
bd2c39f5 | 226 | } |
77675e2a | 227 | |
6e454b9a JK |
228 | void free_tree_buffer(struct tree *tree) |
229 | { | |
230 | free(tree->buffer); | |
231 | tree->buffer = NULL; | |
232 | tree->size = 0; | |
233 | tree->object.parsed = 0; | |
234 | } | |
235 | ||
77675e2a DB |
236 | struct tree *parse_tree_indirect(const unsigned char *sha1) |
237 | { | |
238 | struct object *obj = parse_object(sha1); | |
239 | do { | |
240 | if (!obj) | |
241 | return NULL; | |
1974632c | 242 | if (obj->type == OBJ_TREE) |
77675e2a | 243 | return (struct tree *) obj; |
1974632c | 244 | else if (obj->type == OBJ_COMMIT) |
77675e2a | 245 | obj = &(((struct commit *) obj)->tree->object); |
1974632c | 246 | else if (obj->type == OBJ_TAG) |
77675e2a DB |
247 | obj = ((struct tag *) obj)->tagged; |
248 | else | |
249 | return NULL; | |
250 | if (!obj->parsed) | |
251 | parse_object(obj->sha1); | |
252 | } while (1); | |
253 | } |