@matheusbsbs / matheus-bagliano / commits / 16da134b1f
Fork 0

read-trees: refactor the unpack_trees() part

Basically, the options are passed by a struct unpack_trees_options now. That's all. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <junkio@cox.net>

Johannes Schindelin committed Jul 30, 2006 at 20:25 UTC 16da134b1f9b0fbd1d328999875d34d02e5470b4
4 files changed +521 -485
Makefile
+2 -2
@@ -221,7 +221,7 @@ LIB_H = \
221 blob.h cache.h commit.h csum-file.h delta.h \
222 diff.h object.h pack.h pkt-line.h quote.h refs.h \
223 run-command.h strbuf.h tag.h tree.h git-compat-util.h revision.h \
224 - tree-walk.h log-tree.h dir.h path-list.h
224 + tree-walk.h log-tree.h dir.h path-list.h unpack-trees.h
225
226 DIFF_OBJS = \
227 diff.o diff-lib.o diffcore-break.o diffcore-order.o \
@@ -236,7 +236,7 @@ LIB_OBJS = \
236 server-info.o setup.o sha1_file.o sha1_name.o strbuf.o \
237 tag.o tree.o usage.o config.o environment.o ctype.o copy.o \
238 fetch-clone.o revision.o pager.o tree-walk.o xdiff-interface.o \
239 - alloc.o merge-file.o path-list.o $(DIFF_OBJS)
239 + alloc.o merge-file.o path-list.o unpack-trees.o $(DIFF_OBJS)
240
241 BUILTIN_OBJS = \
242 builtin-log.o builtin-help.o builtin-count.o builtin-diff.o builtin-push.o \
builtin-read-tree.c
+94 -483
@@ -11,411 +11,17 @@
11 #include "tree.h"
12 #include "tree-walk.h"
13 #include "cache-tree.h"
14 -#include <sys/time.h>
15 -#include <signal.h>
14 +#include "unpack-trees.h"
15 #include "builtin.h"
16
18 -static int reset = 0;
19 -static int merge = 0;
20 -static int update = 0;
21 -static int index_only = 0;
22 -static int nontrivial_merge = 0;
23 -static int trivial_merges_only = 0;
24 -static int aggressive = 0;
25 -static int verbose_update = 0;
26 -static volatile int progress_update = 0;
27 -static const char *prefix = NULL;
28 -
29 -static int head_idx = -1;
30 -static int merge_size = 0;
31 -
17 static struct object_list *trees = NULL;
18
34 -static struct cache_entry df_conflict_entry;
35 -
36 -struct tree_entry_list {
37 - struct tree_entry_list *next;
38 - unsigned directory : 1;
39 - unsigned executable : 1;
40 - unsigned symlink : 1;
41 - unsigned int mode;
42 - const char *name;
43 - const unsigned char *sha1;
44 -};
45 -
46 -static struct tree_entry_list df_conflict_list;
47 -
48 -typedef int (*merge_fn_t)(struct cache_entry **src);
49 -
50 -static struct tree_entry_list *create_tree_entry_list(struct tree *tree)
51 -{
52 - struct tree_desc desc;
53 - struct name_entry one;
54 - struct tree_entry_list *ret = NULL;
55 - struct tree_entry_list **list_p = &ret;
56 -
57 - desc.buf = tree->buffer;
58 - desc.size = tree->size;
59 -
60 - while (tree_entry(&desc, &one)) {
61 - struct tree_entry_list *entry;
62 -
63 - entry = xmalloc(sizeof(struct tree_entry_list));
64 - entry->name = one.path;
65 - entry->sha1 = one.sha1;
66 - entry->mode = one.mode;
67 - entry->directory = S_ISDIR(one.mode) != 0;
68 - entry->executable = (one.mode & S_IXUSR) != 0;
69 - entry->symlink = S_ISLNK(one.mode) != 0;
70 - entry->next = NULL;
71 -
72 - *list_p = entry;
73 - list_p = &entry->next;
74 - }
75 - return ret;
76 -}
77 -
78 -static int entcmp(const char *name1, int dir1, const char *name2, int dir2)
79 -{
80 - int len1 = strlen(name1);
81 - int len2 = strlen(name2);
82 - int len = len1 < len2 ? len1 : len2;
83 - int ret = memcmp(name1, name2, len);
84 - unsigned char c1, c2;
85 - if (ret)
86 - return ret;
87 - c1 = name1[len];
88 - c2 = name2[len];
89 - if (!c1 && dir1)
90 - c1 = '/';
91 - if (!c2 && dir2)
92 - c2 = '/';
93 - ret = (c1 < c2) ? -1 : (c1 > c2) ? 1 : 0;
94 - if (c1 && c2 && !ret)
95 - ret = len1 - len2;
96 - return ret;
97 -}
98 -
99 -static int unpack_trees_rec(struct tree_entry_list **posns, int len,
100 - const char *base, merge_fn_t fn, int *indpos)
101 -{
102 - int baselen = strlen(base);
103 - int src_size = len + 1;
104 - do {
105 - int i;
106 - const char *first;
107 - int firstdir = 0;
108 - int pathlen;
109 - unsigned ce_size;
110 - struct tree_entry_list **subposns;
111 - struct cache_entry **src;
112 - int any_files = 0;
113 - int any_dirs = 0;
114 - char *cache_name;
115 - int ce_stage;
116 -
117 - /* Find the first name in the input. */
118 -
119 - first = NULL;
120 - cache_name = NULL;
121 -
122 - /* Check the cache */
123 - if (merge && *indpos < active_nr) {
124 - /* This is a bit tricky: */
125 - /* If the index has a subdirectory (with
126 - * contents) as the first name, it'll get a
127 - * filename like "foo/bar". But that's after
128 - * "foo", so the entry in trees will get
129 - * handled first, at which point we'll go into
130 - * "foo", and deal with "bar" from the index,
131 - * because the base will be "foo/". The only
132 - * way we can actually have "foo/bar" first of
133 - * all the things is if the trees don't
134 - * contain "foo" at all, in which case we'll
135 - * handle "foo/bar" without going into the
136 - * directory, but that's fine (and will return
137 - * an error anyway, with the added unknown
138 - * file case.
139 - */
140 -
141 - cache_name = active_cache[*indpos]->name;
142 - if (strlen(cache_name) > baselen &&
143 - !memcmp(cache_name, base, baselen)) {
144 - cache_name += baselen;
145 - first = cache_name;
146 - } else {
147 - cache_name = NULL;
148 - }
149 - }
150 -
151 -#if DBRT_DEBUG > 1
152 - if (first)
153 - printf("index %s\n", first);
154 -#endif
155 - for (i = 0; i < len; i++) {
156 - if (!posns[i] || posns[i] == &df_conflict_list)
157 - continue;
158 -#if DBRT_DEBUG > 1
159 - printf("%d %s\n", i + 1, posns[i]->name);
160 -#endif
161 - if (!first || entcmp(first, firstdir,
162 - posns[i]->name,
163 - posns[i]->directory) > 0) {
164 - first = posns[i]->name;
165 - firstdir = posns[i]->directory;
166 - }
167 - }
168 - /* No name means we're done */
169 - if (!first)
170 - return 0;
171 -
172 - pathlen = strlen(first);
173 - ce_size = cache_entry_size(baselen + pathlen);
174 -
175 - src = xcalloc(src_size, sizeof(struct cache_entry *));
176 -
177 - subposns = xcalloc(len, sizeof(struct tree_list_entry *));
178 -
179 - if (cache_name && !strcmp(cache_name, first)) {
180 - any_files = 1;
181 - src[0] = active_cache[*indpos];
182 - remove_cache_entry_at(*indpos);
183 - }
184 -
185 - for (i = 0; i < len; i++) {
186 - struct cache_entry *ce;
187 -
188 - if (!posns[i] ||
189 - (posns[i] != &df_conflict_list &&
190 - strcmp(first, posns[i]->name))) {
191 - continue;
192 - }
193 -
194 - if (posns[i] == &df_conflict_list) {
195 - src[i + merge] = &df_conflict_entry;
196 - continue;
197 - }
198 -
199 - if (posns[i]->directory) {
200 - struct tree *tree = lookup_tree(posns[i]->sha1);
201 - any_dirs = 1;
202 - parse_tree(tree);
203 - subposns[i] = create_tree_entry_list(tree);
204 - posns[i] = posns[i]->next;
205 - src[i + merge] = &df_conflict_entry;
206 - continue;
207 - }
208 -
209 - if (!merge)
210 - ce_stage = 0;
211 - else if (i + 1 < head_idx)
212 - ce_stage = 1;
213 - else if (i + 1 > head_idx)
214 - ce_stage = 3;
215 - else
216 - ce_stage = 2;
217 -
218 - ce = xcalloc(1, ce_size);
219 - ce->ce_mode = create_ce_mode(posns[i]->mode);
220 - ce->ce_flags = create_ce_flags(baselen + pathlen,
221 - ce_stage);
222 - memcpy(ce->name, base, baselen);
223 - memcpy(ce->name + baselen, first, pathlen + 1);
224 -
225 - any_files = 1;
226 -
227 - memcpy(ce->sha1, posns[i]->sha1, 20);
228 - src[i + merge] = ce;
229 - subposns[i] = &df_conflict_list;
230 - posns[i] = posns[i]->next;
231 - }
232 - if (any_files) {
233 - if (merge) {
234 - int ret;
235 -
236 -#if DBRT_DEBUG > 1
237 - printf("%s:\n", first);
238 - for (i = 0; i < src_size; i++) {
239 - printf(" %d ", i);
240 - if (src[i])
241 - printf("%s\n", sha1_to_hex(src[i]->sha1));
242 - else
243 - printf("\n");
244 - }
245 -#endif
246 - ret = fn(src);
247 -
248 -#if DBRT_DEBUG > 1
249 - printf("Added %d entries\n", ret);
250 -#endif
251 - *indpos += ret;
252 - } else {
253 - for (i = 0; i < src_size; i++) {
254 - if (src[i]) {
255 - add_cache_entry(src[i], ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK);
256 - }
257 - }
258 - }
259 - }
260 - if (any_dirs) {
261 - char *newbase = xmalloc(baselen + 2 + pathlen);
262 - memcpy(newbase, base, baselen);
263 - memcpy(newbase + baselen, first, pathlen);
264 - newbase[baselen + pathlen] = '/';
265 - newbase[baselen + pathlen + 1] = '\0';
266 - if (unpack_trees_rec(subposns, len, newbase, fn,
267 - indpos))
268 - return -1;
269 - free(newbase);
270 - }
271 - free(subposns);
272 - free(src);
273 - } while (1);
274 -}
275 -
19 static void reject_merge(struct cache_entry *ce)
20 {
278 - die("Entry '%s' would be overwritten by merge. Cannot merge.",
21 + die("Entry '%s' would be overwritten by merge. Cannot merge.",
22 ce->name);
23 }
24
282 -/* Unlink the last component and attempt to remove leading
283 - * directories, in case this unlink is the removal of the
284 - * last entry in the directory -- empty directories are removed.
285 - */
286 -static void unlink_entry(char *name)
287 -{
288 - char *cp, *prev;
289 -
290 - if (unlink(name))
291 - return;
292 - prev = NULL;
293 - while (1) {
294 - int status;
295 - cp = strrchr(name, '/');
296 - if (prev)
297 - *prev = '/';
298 - if (!cp)
299 - break;
300 -
301 - *cp = 0;
302 - status = rmdir(name);
303 - if (status) {
304 - *cp = '/';
305 - break;
306 - }
307 - prev = cp;
308 - }
309 -}
310 -
311 -static void progress_interval(int signum)
312 -{
313 - progress_update = 1;
314 -}
315 -
316 -static void setup_progress_signal(void)
317 -{
318 - struct sigaction sa;
319 - struct itimerval v;
320 -
321 - memset(&sa, 0, sizeof(sa));
322 - sa.sa_handler = progress_interval;
323 - sigemptyset(&sa.sa_mask);
324 - sa.sa_flags = SA_RESTART;
325 - sigaction(SIGALRM, &sa, NULL);
326 -
327 - v.it_interval.tv_sec = 1;
328 - v.it_interval.tv_usec = 0;
329 - v.it_value = v.it_interval;
330 - setitimer(ITIMER_REAL, &v, NULL);
331 -}
332 -
333 -static struct checkout state;
334 -static void check_updates(struct cache_entry **src, int nr)
335 -{
336 - unsigned short mask = htons(CE_UPDATE);
337 - unsigned last_percent = 200, cnt = 0, total = 0;
338 -
339 - if (update && verbose_update) {
340 - for (total = cnt = 0; cnt < nr; cnt++) {
341 - struct cache_entry *ce = src[cnt];
342 - if (!ce->ce_mode || ce->ce_flags & mask)
343 - total++;
344 - }
345 -
346 - /* Don't bother doing this for very small updates */
347 - if (total < 250)
348 - total = 0;
349 -
350 - if (total) {
351 - fprintf(stderr, "Checking files out...\n");
352 - setup_progress_signal();
353 - progress_update = 1;
354 - }
355 - cnt = 0;
356 - }
357 -
358 - while (nr--) {
359 - struct cache_entry *ce = *src++;
360 -
361 - if (total) {
362 - if (!ce->ce_mode || ce->ce_flags & mask) {
363 - unsigned percent;
364 - cnt++;
365 - percent = (cnt * 100) / total;
366 - if (percent != last_percent ||
367 - progress_update) {
368 - fprintf(stderr, "%4u%% (%u/%u) done\r",
369 - percent, cnt, total);
370 - last_percent = percent;
371 - progress_update = 0;
372 - }
373 - }
374 - }
375 - if (!ce->ce_mode) {
376 - if (update)
377 - unlink_entry(ce->name);
378 - continue;
379 - }
380 - if (ce->ce_flags & mask) {
381 - ce->ce_flags &= ~mask;
382 - if (update)
383 - checkout_entry(ce, &state, NULL);
384 - }
385 - }
386 - if (total) {
387 - signal(SIGALRM, SIG_IGN);
388 - fputc('\n', stderr);
389 - }
390 -}
391 -
392 -static int unpack_trees(merge_fn_t fn)
393 -{
394 - int indpos = 0;
395 - unsigned len = object_list_length(trees);
396 - struct tree_entry_list **posns;
397 - int i;
398 - struct object_list *posn = trees;
399 - merge_size = len;
400 -
401 - if (len) {
402 - posns = xmalloc(len * sizeof(struct tree_entry_list *));
403 - for (i = 0; i < len; i++) {
404 - posns[i] = create_tree_entry_list((struct tree *) posn->item);
405 - posn = posn->next;
406 - }
407 - if (unpack_trees_rec(posns, len, prefix ? prefix : "",
408 - fn, &indpos))
409 - return -1;
410 - }
411 -
412 - if (trivial_merges_only && nontrivial_merge)
413 - die("Merge requires file-level merging");
414 -
415 - check_updates(active_cache, active_nr);
416 - return 0;
417 -}
418 -
25 static int list_tree(unsigned char *sha1)
26 {
27 struct tree *tree = parse_tree_indirect(sha1);
@@ -440,11 +46,12 @@ static int same(struct cache_entry *a, struct cache_entry *b)
46 * When a CE gets turned into an unmerged entry, we
47 * want it to be up-to-date
48 */
443 -static void verify_uptodate(struct cache_entry *ce)
49 +static void verify_uptodate(struct cache_entry *ce,
50 + struct unpack_trees_options *o)
51 {
52 struct stat st;
53
447 - if (index_only || reset)
54 + if (o->index_only || o->reset)
55 return;
56
57 if (!lstat(ce->name, &st)) {
@@ -453,7 +60,7 @@ static void verify_uptodate(struct cache_entry *ce)
60 return;
61 errno = 0;
62 }
456 - if (reset) {
63 + if (o->reset) {
64 ce->ce_flags |= htons(CE_UPDATE);
65 return;
66 }
@@ -472,18 +79,20 @@ static void invalidate_ce_path(struct cache_entry *ce)
79 * We do not want to remove or overwrite a working tree file that
80 * is not tracked.
81 */
475 -static void verify_absent(const char *path, const char *action)
82 +static void verify_absent(const char *path, const char *action,
83 + struct unpack_trees_options *o)
84 {
85 struct stat st;
86
479 - if (index_only || reset || !update)
87 + if (o->index_only || o->reset || !o->update)
88 return;
89 if (!lstat(path, &st))
90 die("Untracked working tree file '%s' "
91 "would be %s by merge.", path, action);
92 }
93
486 -static int merged_entry(struct cache_entry *merge, struct cache_entry *old)
94 +static int merged_entry(struct cache_entry *merge, struct cache_entry *old,
95 + struct unpack_trees_options *o)
96 {
97 merge->ce_flags |= htons(CE_UPDATE);
98 if (old) {
@@ -497,12 +106,12 @@ static int merged_entry(struct cache_entry *merge, struct cache_entry *old)
106 if (same(old, merge)) {
107 *merge = *old;
108 } else {
500 - verify_uptodate(old);
109 + verify_uptodate(old, o);
110 invalidate_ce_path(old);
111 }
112 }
113 else {
505 - verify_absent(merge->name, "overwritten");
114 + verify_absent(merge->name, "overwritten", o);
115 invalidate_ce_path(merge);
116 }
117
@@ -511,12 +120,13 @@ static int merged_entry(struct cache_entry *merge, struct cache_entry *old)
120 return 1;
121 }
122
514 -static int deleted_entry(struct cache_entry *ce, struct cache_entry *old)
123 +static int deleted_entry(struct cache_entry *ce, struct cache_entry *old,
124 + struct unpack_trees_options *o)
125 {
126 if (old)
517 - verify_uptodate(old);
127 + verify_uptodate(old, o);
128 else
519 - verify_absent(ce->name, "removed");
129 + verify_absent(ce->name, "removed", o);
130 ce->ce_mode = 0;
131 add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);
132 invalidate_ce_path(ce);
@@ -545,11 +155,12 @@ static void show_stage_entry(FILE *o,
155 }
156 #endif
157
548 -static int threeway_merge(struct cache_entry **stages)
158 +static int threeway_merge(struct cache_entry **stages,
159 + struct unpack_trees_options *o)
160 {
161 struct cache_entry *index;
551 - struct cache_entry *head;
552 - struct cache_entry *remote = stages[head_idx + 1];
162 + struct cache_entry *head;
163 + struct cache_entry *remote = stages[o->head_idx + 1];
164 int count;
165 int head_match = 0;
166 int remote_match = 0;
@@ -562,7 +173,7 @@ static int threeway_merge(struct cache_entry **stages)
173 int no_anc_exists = 1;
174 int i;
175
565 - for (i = 1; i < head_idx; i++) {
176 + for (i = 1; i < o->head_idx; i++) {
177 if (!stages[i])
178 any_anc_missing = 1;
179 else {
@@ -573,14 +184,14 @@ static int threeway_merge(struct cache_entry **stages)
184 }
185
186 index = stages[0];
576 - head = stages[head_idx];
187 + head = stages[o->head_idx];
188
578 - if (head == &df_conflict_entry) {
189 + if (head == &o->df_conflict_entry) {
190 df_conflict_head = 1;
191 head = NULL;
192 }
193
583 - if (remote == &df_conflict_entry) {
194 + if (remote == &o->df_conflict_entry) {
195 df_conflict_remote = 1;
196 remote = NULL;
197 }
@@ -596,7 +207,7 @@ static int threeway_merge(struct cache_entry **stages)
207 * and #14.
208 */
209 if (!same(remote, head)) {
599 - for (i = 1; i < head_idx; i++) {
210 + for (i = 1; i < o->head_idx; i++) {
211 if (same(stages[i], head)) {
212 head_match = i;
213 }
@@ -614,7 +225,7 @@ static int threeway_merge(struct cache_entry **stages)
225 if (remote && !df_conflict_head && head_match && !remote_match) {
226 if (index && !same(index, remote) && !same(index, head))
227 reject_merge(index);
617 - return merged_entry(remote, index);
228 + return merged_entry(remote, index, o);
229 }
230 /*
231 * If we have an entry in the index cache, then we want to
@@ -627,10 +238,10 @@ static int threeway_merge(struct cache_entry **stages)
238 if (head) {
239 /* #5ALT, #15 */
240 if (same(head, remote))
630 - return merged_entry(head, index);
241 + return merged_entry(head, index, o);
242 /* #13, #3ALT */
243 if (!df_conflict_remote && remote_match && !head_match)
633 - return merged_entry(head, index);
244 + return merged_entry(head, index, o);
245 }
246
247 /* #1 */
@@ -640,7 +251,7 @@ static int threeway_merge(struct cache_entry **stages)
251 /* Under the new "aggressive" rule, we resolve mostly trivial
252 * cases that we historically had git-merge-one-file resolve.
253 */
643 - if (aggressive) {
254 + if (o->aggressive) {
255 int head_deleted = !head && !df_conflict_head;
256 int remote_deleted = !remote && !df_conflict_remote;
257 /*
@@ -651,35 +262,35 @@ static int threeway_merge(struct cache_entry **stages)
262 (head_deleted && remote && remote_match) ||
263 (remote_deleted && head && head_match)) {
264 if (index)
654 - return deleted_entry(index, index);
265 + return deleted_entry(index, index, o);
266 else if (path)
656 - verify_absent(path, "removed");
267 + verify_absent(path, "removed", o);
268 return 0;
269 }
270 /*
271 * Added in both, identically.
272 */
273 if (no_anc_exists && head && remote && same(head, remote))
663 - return merged_entry(head, index);
274 + return merged_entry(head, index, o);
275
276 }
277
278 /* Below are "no merge" cases, which require that the index be
279 * up-to-date to avoid the files getting overwritten with
669 - * conflict resolution files.
280 + * conflict resolution files.
281 */
282 if (index) {
672 - verify_uptodate(index);
283 + verify_uptodate(index, o);
284 }
285 else if (path)
675 - verify_absent(path, "overwritten");
286 + verify_absent(path, "overwritten", o);
287
677 - nontrivial_merge = 1;
288 + o->nontrivial_merge = 1;
289
290 /* #2, #3, #4, #6, #7, #9, #11. */
291 count = 0;
292 if (!head_match || !remote_match) {
682 - for (i = 1; i < head_idx; i++) {
293 + for (i = 1; i < o->head_idx; i++) {
294 if (stages[i]) {
295 keep_entry(stages[i]);
296 count++;
@@ -708,14 +319,15 @@ static int threeway_merge(struct cache_entry **stages)
319 * "carry forward" rule, please see <Documentation/git-read-tree.txt>.
320 *
321 */
711 -static int twoway_merge(struct cache_entry **src)
322 +static int twoway_merge(struct cache_entry **src,
323 + struct unpack_trees_options *o)
324 {
325 struct cache_entry *current = src[0];
326 struct cache_entry *oldtree = src[1], *newtree = src[2];
327
716 - if (merge_size != 2)
328 + if (o->merge_size != 2)
329 return error("Cannot do a twoway merge of %d trees",
718 - merge_size);
330 + o->merge_size);
331
332 if (current) {
333 if ((!oldtree && !newtree) || /* 4 and 5 */
@@ -730,12 +342,12 @@ static int twoway_merge(struct cache_entry **src)
342 }
343 else if (oldtree && !newtree && same(current, oldtree)) {
344 /* 10 or 11 */
733 - return deleted_entry(oldtree, current);
345 + return deleted_entry(oldtree, current, o);
346 }
347 else if (oldtree && newtree &&
348 same(current, oldtree) && !same(current, newtree)) {
349 /* 20 or 21 */
738 - return merged_entry(newtree, current);
350 + return merged_entry(newtree, current, o);
351 }
352 else {
353 /* all other failures */
@@ -749,9 +361,9 @@ static int twoway_merge(struct cache_entry **src)
361 }
362 }
363 else if (newtree)
752 - return merged_entry(newtree, current);
364 + return merged_entry(newtree, current, o);
365 else
754 - return deleted_entry(oldtree, current);
366 + return deleted_entry(oldtree, current, o);
367 }
368
369 /*
@@ -760,20 +372,21 @@ static int twoway_merge(struct cache_entry **src)
372 * Keep the index entries at stage0, collapse stage1 but make sure
373 * stage0 does not have anything there.
374 */
763 -static int bind_merge(struct cache_entry **src)
375 +static int bind_merge(struct cache_entry **src,
376 + struct unpack_trees_options *o)
377 {
378 struct cache_entry *old = src[0];
379 struct cache_entry *a = src[1];
380
768 - if (merge_size != 1)
381 + if (o->merge_size != 1)
382 return error("Cannot do a bind merge of %d trees\n",
770 - merge_size);
383 + o->merge_size);
384 if (a && old)
385 die("Entry '%s' overlaps. Cannot bind.", a->name);
386 if (!a)
387 return keep_entry(old);
388 else
776 - return merged_entry(a, NULL);
389 + return merged_entry(a, NULL, o);
390 }
391
392 /*
@@ -782,19 +395,20 @@ static int bind_merge(struct cache_entry **src)
395 * The rule is:
396 * - take the stat information from stage0, take the data from stage1
397 */
785 -static int oneway_merge(struct cache_entry **src)
398 +static int oneway_merge(struct cache_entry **src,
399 + struct unpack_trees_options *o)
400 {
401 struct cache_entry *old = src[0];
402 struct cache_entry *a = src[1];
403
790 - if (merge_size != 1)
404 + if (o->merge_size != 1)
405 return error("Cannot do a oneway merge of %d trees",
792 - merge_size);
406 + o->merge_size);
407
408 if (!a)
795 - return deleted_entry(old, old);
409 + return deleted_entry(old, old, o);
410 if (old && same(old, a)) {
797 - if (reset) {
411 + if (o->reset) {
412 struct stat st;
413 if (lstat(old->name, &st) ||
414 ce_match_stat(old, &st, 1))
@@ -802,7 +416,7 @@ static int oneway_merge(struct cache_entry **src)
416 }
417 return keep_entry(old);
418 }
805 - return merged_entry(a, old);
419 + return merged_entry(a, old, o);
420 }
421
422 static int read_cache_unmerged(void)
@@ -874,14 +488,12 @@ int cmd_read_tree(int argc, const char **argv, const char *prefix)
488 {
489 int i, newfd, stage = 0;
490 unsigned char sha1[20];
877 - merge_fn_t fn = NULL;
491 + struct unpack_trees_options opts;
492
879 - df_conflict_list.next = &df_conflict_list;
880 - state.base_dir = "";
881 - state.force = 1;
882 - state.quiet = 1;
883 - state.refresh_cache = 1;
493 + memset(&opts, 0, sizeof(opts));
494 + opts.head_idx = -1;
495
496 + setup_git_directory();
497 git_config(git_default_config);
498
499 newfd = hold_lock_file_for_update(&lock_file, get_index_file());
@@ -890,8 +502,6 @@ int cmd_read_tree(int argc, const char **argv, const char *prefix)
502
503 git_config(git_default_config);
504
893 - merge = 0;
894 - reset = 0;
505 for (i = 1; i < argc; i++) {
506 const char *arg = argv[i];
507
@@ -899,12 +509,12 @@ int cmd_read_tree(int argc, const char **argv, const char *prefix)
509 * the working tree.
510 */
511 if (!strcmp(arg, "-u")) {
902 - update = 1;
512 + opts.update = 1;
513 continue;
514 }
515
516 if (!strcmp(arg, "-v")) {
907 - verbose_update = 1;
517 + opts.verbose_update = 1;
518 continue;
519 }
520
@@ -912,7 +522,7 @@ int cmd_read_tree(int argc, const char **argv, const char *prefix)
522 * not even look at the working tree.
523 */
524 if (!strcmp(arg, "-i")) {
915 - index_only = 1;
525 + opts.index_only = 1;
526 continue;
527 }
528
@@ -921,10 +531,10 @@ int cmd_read_tree(int argc, const char **argv, const char *prefix)
531 * given subdirectory.
532 */
533 if (!strncmp(arg, "--prefix=", 9)) {
924 - if (stage || merge || prefix)
534 + if (stage || opts.merge || opts.prefix)
535 usage(read_tree_usage);
926 - prefix = arg + 9;
927 - merge = 1;
536 + opts.prefix = arg + 9;
537 + opts.merge = 1;
538 stage = 1;
539 if (read_cache_unmerged())
540 die("you need to resolve your current index first");
@@ -936,38 +546,38 @@ int cmd_read_tree(int argc, const char **argv, const char *prefix)
546 * correspond to them.
547 */
548 if (!strcmp(arg, "--reset")) {
939 - if (stage || merge || prefix)
549 + if (stage || opts.merge || opts.prefix)
550 usage(read_tree_usage);
941 - reset = 1;
942 - merge = 1;
551 + opts.reset = 1;
552 + opts.merge = 1;
553 stage = 1;
554 read_cache_unmerged();
555 continue;
556 }
557
558 if (!strcmp(arg, "--trivial")) {
949 - trivial_merges_only = 1;
559 + opts.trivial_merges_only = 1;
560 continue;
561 }
562
563 if (!strcmp(arg, "--aggressive")) {
954 - aggressive = 1;
564 + opts.aggressive = 1;
565 continue;
566 }
567
568 /* "-m" stands for "merge", meaning we start in stage 1 */
569 if (!strcmp(arg, "-m")) {
960 - if (stage || merge || prefix)
570 + if (stage || opts.merge || opts.prefix)
571 usage(read_tree_usage);
572 if (read_cache_unmerged())
573 die("you need to resolve your current index first");
574 stage = 1;
965 - merge = 1;
575 + opts.merge = 1;
576 continue;
577 }
578
579 /* using -u and -i at the same time makes no sense */
970 - if (1 < index_only + update)
580 + if (1 < opts.index_only + opts.update)
581 usage(read_tree_usage);
582
583 if (get_sha1(arg, sha1))
@@ -976,52 +586,53 @@ int cmd_read_tree(int argc, const char **argv, const char *prefix)
586 die("failed to unpack tree object %s", arg);
587 stage++;
588 }
979 - if ((update||index_only) && !merge)
589 + if ((opts.update||opts.index_only) && !opts.merge)
590 usage(read_tree_usage);
591
982 - if (prefix) {
983 - int pfxlen = strlen(prefix);
592 + if (opts.prefix) {
593 + int pfxlen = strlen(opts.prefix);
594 int pos;
985 - if (prefix[pfxlen-1] != '/')
595 + if (opts.prefix[pfxlen-1] != '/')
596 die("prefix must end with /");
597 if (stage != 2)
598 die("binding merge takes only one tree");
989 - pos = cache_name_pos(prefix, pfxlen);
599 + pos = cache_name_pos(opts.prefix, pfxlen);
600 if (0 <= pos)
601 die("corrupt index file");
602 pos = -pos-1;
603 if (pos < active_nr &&
994 - !strncmp(active_cache[pos]->name, prefix, pfxlen))
995 - die("subdirectory '%s' already exists.", prefix);
996 - pos = cache_name_pos(prefix, pfxlen-1);
604 + !strncmp(active_cache[pos]->name, opts.prefix, pfxlen))
605 + die("subdirectory '%s' already exists.", opts.prefix);
606 + pos = cache_name_pos(opts.prefix, pfxlen-1);
607 if (0 <= pos)
998 - die("file '%.*s' already exists.", pfxlen-1, prefix);
608 + die("file '%.*s' already exists.",
609 + pfxlen-1, opts.prefix);
610 }
611
1001 - if (merge) {
612 + if (opts.merge) {
613 if (stage < 2)
614 die("just how do you expect me to merge %d trees?", stage-1);
615 switch (stage - 1) {
616 case 1:
1006 - fn = prefix ? bind_merge : oneway_merge;
617 + opts.fn = opts.prefix ? bind_merge : oneway_merge;
618 break;
619 case 2:
1009 - fn = twoway_merge;
620 + opts.fn = twoway_merge;
621 break;
622 case 3:
623 default:
1013 - fn = threeway_merge;
624 + opts.fn = threeway_merge;
625 cache_tree_free(&active_cache_tree);
626 break;
627 }
628
629 if (stage - 1 >= 3)
1019 - head_idx = stage - 2;
630 + opts.head_idx = stage - 2;
631 else
1021 - head_idx = 1;
632 + opts.head_idx = 1;
633 }
634
1024 - unpack_trees(fn);
635 + unpack_trees(trees, &opts);
636
637 /*
638 * When reading only one tree (either the most basic form,
@@ -1029,7 +640,7 @@ int cmd_read_tree(int argc, const char **argv, const char *prefix)
640 * valid cache-tree because the index must match exactly
641 * what came from the tree.
642 */
1032 - if (trees && trees->item && !prefix && (!merge || (stage == 2))) {
643 + if (trees && trees->item && !opts.prefix && (!opts.merge || (stage == 2))) {
644 cache_tree_free(&active_cache_tree);
645 prime_cache_tree();
646 }
unpack-trees.c new
+395
@@ -0,0 +1,395 @@
1 +#include <signal.h>
2 +#include <sys/time.h>
3 +#include "cache.h"
4 +#include "tree.h"
5 +#include "tree-walk.h"
6 +#include "unpack-trees.h"
7 +
8 +struct tree_entry_list {
9 + struct tree_entry_list *next;
10 + unsigned directory : 1;
11 + unsigned executable : 1;
12 + unsigned symlink : 1;
13 + unsigned int mode;
14 + const char *name;
15 + const unsigned char *sha1;
16 +};
17 +
18 +static struct tree_entry_list *create_tree_entry_list(struct tree *tree)
19 +{
20 + struct tree_desc desc;
21 + struct name_entry one;
22 + struct tree_entry_list *ret = NULL;
23 + struct tree_entry_list **list_p = &ret;
24 +
25 + desc.buf = tree->buffer;
26 + desc.size = tree->size;
27 +
28 + while (tree_entry(&desc, &one)) {
29 + struct tree_entry_list *entry;
30 +
31 + entry = xmalloc(sizeof(struct tree_entry_list));
32 + entry->name = one.path;
33 + entry->sha1 = one.sha1;
34 + entry->mode = one.mode;
35 + entry->directory = S_ISDIR(one.mode) != 0;
36 + entry->executable = (one.mode & S_IXUSR) != 0;
37 + entry->symlink = S_ISLNK(one.mode) != 0;
38 + entry->next = NULL;
39 +
40 + *list_p = entry;
41 + list_p = &entry->next;
42 + }
43 + return ret;
44 +}
45 +
46 +static int entcmp(const char *name1, int dir1, const char *name2, int dir2)
47 +{
48 + int len1 = strlen(name1);
49 + int len2 = strlen(name2);
50 + int len = len1 < len2 ? len1 : len2;
51 + int ret = memcmp(name1, name2, len);
52 + unsigned char c1, c2;
53 + if (ret)
54 + return ret;
55 + c1 = name1[len];
56 + c2 = name2[len];
57 + if (!c1 && dir1)
58 + c1 = '/';
59 + if (!c2 && dir2)
60 + c2 = '/';
61 + ret = (c1 < c2) ? -1 : (c1 > c2) ? 1 : 0;
62 + if (c1 && c2 && !ret)
63 + ret = len1 - len2;
64 + return ret;
65 +}
66 +
67 +static int unpack_trees_rec(struct tree_entry_list **posns, int len,
68 + const char *base, struct unpack_trees_options *o,
69 + int *indpos,
70 + struct tree_entry_list *df_conflict_list)
71 +{
72 + int baselen = strlen(base);
73 + int src_size = len + 1;
74 + do {
75 + int i;
76 + const char *first;
77 + int firstdir = 0;
78 + int pathlen;
79 + unsigned ce_size;
80 + struct tree_entry_list **subposns;
81 + struct cache_entry **src;
82 + int any_files = 0;
83 + int any_dirs = 0;
84 + char *cache_name;
85 + int ce_stage;
86 +
87 + /* Find the first name in the input. */
88 +
89 + first = NULL;
90 + cache_name = NULL;
91 +
92 + /* Check the cache */
93 + if (o->merge && *indpos < active_nr) {
94 + /* This is a bit tricky: */
95 + /* If the index has a subdirectory (with
96 + * contents) as the first name, it'll get a
97 + * filename like "foo/bar". But that's after
98 + * "foo", so the entry in trees will get
99 + * handled first, at which point we'll go into
100 + * "foo", and deal with "bar" from the index,
101 + * because the base will be "foo/". The only
102 + * way we can actually have "foo/bar" first of
103 + * all the things is if the trees don't
104 + * contain "foo" at all, in which case we'll
105 + * handle "foo/bar" without going into the
106 + * directory, but that's fine (and will return
107 + * an error anyway, with the added unknown
108 + * file case.
109 + */
110 +
111 + cache_name = active_cache[*indpos]->name;
112 + if (strlen(cache_name) > baselen &&
113 + !memcmp(cache_name, base, baselen)) {
114 + cache_name += baselen;
115 + first = cache_name;
116 + } else {
117 + cache_name = NULL;
118 + }
119 + }
120 +
121 +#if DBRT_DEBUG > 1
122 + if (first)
123 + printf("index %s\n", first);
124 +#endif
125 + for (i = 0; i < len; i++) {
126 + if (!posns[i] || posns[i] == df_conflict_list)
127 + continue;
128 +#if DBRT_DEBUG > 1
129 + printf("%d %s\n", i + 1, posns[i]->name);
130 +#endif
131 + if (!first || entcmp(first, firstdir,
132 + posns[i]->name,
133 + posns[i]->directory) > 0) {
134 + first = posns[i]->name;
135 + firstdir = posns[i]->directory;
136 + }
137 + }
138 + /* No name means we're done */
139 + if (!first)
140 + return 0;
141 +
142 + pathlen = strlen(first);
143 + ce_size = cache_entry_size(baselen + pathlen);
144 +
145 + src = xcalloc(src_size, sizeof(struct cache_entry *));
146 +
147 + subposns = xcalloc(len, sizeof(struct tree_list_entry *));
148 +
149 + if (cache_name && !strcmp(cache_name, first)) {
150 + any_files = 1;
151 + src[0] = active_cache[*indpos];
152 + remove_cache_entry_at(*indpos);
153 + }
154 +
155 + for (i = 0; i < len; i++) {
156 + struct cache_entry *ce;
157 +
158 + if (!posns[i] ||
159 + (posns[i] != df_conflict_list &&
160 + strcmp(first, posns[i]->name))) {
161 + continue;
162 + }
163 +
164 + if (posns[i] == df_conflict_list) {
165 + src[i + o->merge] = o->df_conflict_entry;
166 + continue;
167 + }
168 +
169 + if (posns[i]->directory) {
170 + struct tree *tree = lookup_tree(posns[i]->sha1);
171 + any_dirs = 1;
172 + parse_tree(tree);
173 + subposns[i] = create_tree_entry_list(tree);
174 + posns[i] = posns[i]->next;
175 + src[i + o->merge] = o->df_conflict_entry;
176 + continue;
177 + }
178 +
179 + if (!o->merge)
180 + ce_stage = 0;
181 + else if (i + 1 < o->head_idx)
182 + ce_stage = 1;
183 + else if (i + 1 > o->head_idx)
184 + ce_stage = 3;
185 + else
186 + ce_stage = 2;
187 +
188 + ce = xcalloc(1, ce_size);
189 + ce->ce_mode = create_ce_mode(posns[i]->mode);
190 + ce->ce_flags = create_ce_flags(baselen + pathlen,
191 + ce_stage);
192 + memcpy(ce->name, base, baselen);
193 + memcpy(ce->name + baselen, first, pathlen + 1);
194 +
195 + any_files = 1;
196 +
197 + memcpy(ce->sha1, posns[i]->sha1, 20);
198 + src[i + o->merge] = ce;
199 + subposns[i] = df_conflict_list;
200 + posns[i] = posns[i]->next;
201 + }
202 + if (any_files) {
203 + if (o->merge) {
204 + int ret;
205 +
206 +#if DBRT_DEBUG > 1
207 + printf("%s:\n", first);
208 + for (i = 0; i < src_size; i++) {
209 + printf(" %d ", i);
210 + if (src[i])
211 + printf("%s\n", sha1_to_hex(src[i]->sha1));
212 + else
213 + printf("\n");
214 + }
215 +#endif
216 + ret = o->fn(src, o);
217 +
218 +#if DBRT_DEBUG > 1
219 + printf("Added %d entries\n", ret);
220 +#endif
221 + *indpos += ret;
222 + } else {
223 + for (i = 0; i < src_size; i++) {
224 + if (src[i]) {
225 + add_cache_entry(src[i], ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK);
226 + }
227 + }
228 + }
229 + }
230 + if (any_dirs) {
231 + char *newbase = xmalloc(baselen + 2 + pathlen);
232 + memcpy(newbase, base, baselen);
233 + memcpy(newbase + baselen, first, pathlen);
234 + newbase[baselen + pathlen] = '/';
235 + newbase[baselen + pathlen + 1] = '\0';
236 + if (unpack_trees_rec(subposns, len, newbase, o,
237 + indpos, df_conflict_list))
238 + return -1;
239 + free(newbase);
240 + }
241 + free(subposns);
242 + free(src);
243 + } while (1);
244 +}
245 +
246 +/* Unlink the last component and attempt to remove leading
247 + * directories, in case this unlink is the removal of the
248 + * last entry in the directory -- empty directories are removed.
249 + */
250 +static void unlink_entry(char *name)
251 +{
252 + char *cp, *prev;
253 +
254 + if (unlink(name))
255 + return;
256 + prev = NULL;
257 + while (1) {
258 + int status;
259 + cp = strrchr(name, '/');
260 + if (prev)
261 + *prev = '/';
262 + if (!cp)
263 + break;
264 +
265 + *cp = 0;
266 + status = rmdir(name);
267 + if (status) {
268 + *cp = '/';
269 + break;
270 + }
271 + prev = cp;
272 + }
273 +}
274 +
275 +static volatile int progress_update = 0;
276 +
277 +static void progress_interval(int signum)
278 +{
279 + progress_update = 1;
280 +}
281 +
282 +static void setup_progress_signal(void)
283 +{
284 + struct sigaction sa;
285 + struct itimerval v;
286 +
287 + memset(&sa, 0, sizeof(sa));
288 + sa.sa_handler = progress_interval;
289 + sigemptyset(&sa.sa_mask);
290 + sa.sa_flags = SA_RESTART;
291 + sigaction(SIGALRM, &sa, NULL);
292 +
293 + v.it_interval.tv_sec = 1;
294 + v.it_interval.tv_usec = 0;
295 + v.it_value = v.it_interval;
296 + setitimer(ITIMER_REAL, &v, NULL);
297 +}
298 +
299 +static struct checkout state;
300 +static void check_updates(struct cache_entry **src, int nr,
301 + struct unpack_trees_options *o)
302 +{
303 + unsigned short mask = htons(CE_UPDATE);
304 + unsigned last_percent = 200, cnt = 0, total = 0;
305 +
306 + if (o->update && o->verbose_update) {
307 + for (total = cnt = 0; cnt < nr; cnt++) {
308 + struct cache_entry *ce = src[cnt];
309 + if (!ce->ce_mode || ce->ce_flags & mask)
310 + total++;
311 + }
312 +
313 + /* Don't bother doing this for very small updates */
314 + if (total < 250)
315 + total = 0;
316 +
317 + if (total) {
318 + fprintf(stderr, "Checking files out...\n");
319 + setup_progress_signal();
320 + progress_update = 1;
321 + }
322 + cnt = 0;
323 + }
324 +
325 + while (nr--) {
326 + struct cache_entry *ce = *src++;
327 +
328 + if (total) {
329 + if (!ce->ce_mode || ce->ce_flags & mask) {
330 + unsigned percent;
331 + cnt++;
332 + percent = (cnt * 100) / total;
333 + if (percent != last_percent ||
334 + progress_update) {
335 + fprintf(stderr, "%4u%% (%u/%u) done\r",
336 + percent, cnt, total);
337 + last_percent = percent;
338 + progress_update = 0;
339 + }
340 + }
341 + }
342 + if (!ce->ce_mode) {
343 + if (o->update)
344 + unlink_entry(ce->name);
345 + continue;
346 + }
347 + if (ce->ce_flags & mask) {
348 + ce->ce_flags &= ~mask;
349 + if (o->update)
350 + checkout_entry(ce, &state, NULL);
351 + }
352 + }
353 + if (total) {
354 + signal(SIGALRM, SIG_IGN);
355 + fputc('\n', stderr);
356 + }
357 +}
358 +
359 +int unpack_trees(struct object_list *trees, struct unpack_trees_options *o)
360 +{
361 + int indpos = 0;
362 + unsigned len = object_list_length(trees);
363 + struct tree_entry_list **posns;
364 + int i;
365 + struct object_list *posn = trees;
366 + struct tree_entry_list df_conflict_list;
367 + struct cache_entry df_conflict_entry;
368 +
369 + memset(&df_conflict_list, 0, sizeof(df_conflict_list));
370 + df_conflict_list.next = &df_conflict_list;
371 + state.base_dir = "";
372 + state.force = 1;
373 + state.quiet = 1;
374 + state.refresh_cache = 1;
375 +
376 + o->merge_size = len;
377 + o->df_conflict_entry = &df_conflict_entry;
378 +
379 + if (len) {
380 + posns = xmalloc(len * sizeof(struct tree_entry_list *));
381 + for (i = 0; i < len; i++) {
382 + posns[i] = create_tree_entry_list((struct tree *) posn->item);
383 + posn = posn->next;
384 + }
385 + if (unpack_trees_rec(posns, len, o->prefix ? o->prefix : "",
386 + o, &indpos, &df_conflict_list))
387 + return -1;
388 + }
389 +
390 + if (o->trivial_merges_only && o->nontrivial_merge)
391 + die("Merge requires file-level merging");
392 +
393 + check_updates(active_cache, active_nr, o);
394 + return 0;
395 +}
unpack-trees.h new
+30
@@ -0,0 +1,30 @@
1 +#ifndef UNPACK_TREES_H
2 +#define UNPACK_TREES_H
3 +
4 +struct unpack_trees_options;
5 +
6 +typedef int (*merge_fn_t)(struct cache_entry **src,
7 + struct unpack_trees_options *options);
8 +
9 +struct unpack_trees_options {
10 + int reset;
11 + int merge;
12 + int update;
13 + int index_only;
14 + int nontrivial_merge;
15 + int trivial_merges_only;
16 + int verbose_update;
17 + int aggressive;
18 + const char *prefix;
19 + merge_fn_t fn;
20 +
21 + int head_idx;
22 + int merge_size;
23 +
24 + struct cache_entry *df_conflict_entry;
25 +};
26 +
27 +extern int unpack_trees(struct object_list *trees,
28 + struct unpack_trees_options *options);
29 +
30 +#endif