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