read-trees: refactor the unpack_trees() part
[git/git.git] / unpack-trees.c
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 }