merge-recursive: handle D/F conflict case more carefully.
[git] / tree-walk.c
1 #include "cache.h"
2 #include "tree-walk.h"
3 #include "tree.h"
4
5 static const char *get_mode(const char *str, unsigned int *modep)
6 {
7         unsigned char c;
8         unsigned int mode = 0;
9
10         while ((c = *str++) != ' ') {
11                 if (c < '0' || c > '7')
12                         return NULL;
13                 mode = (mode << 3) + (c - '0');
14         }
15         *modep = mode;
16         return str;
17 }
18
19 static void decode_tree_entry(struct tree_desc *desc, const void *buf, unsigned long size)
20 {
21         const char *path;
22         unsigned int mode, len;
23
24         path = get_mode(buf, &mode);
25         if (!path)
26                 die("corrupt tree file");
27         len = strlen(path) + 1;
28
29         /* Initialize the descriptor entry */
30         desc->entry.path = path;
31         desc->entry.mode = mode;
32         desc->entry.sha1 = (const unsigned char *)(path + len);
33 }
34
35 void init_tree_desc(struct tree_desc *desc, const void *buffer, unsigned long size)
36 {
37         desc->buffer = buffer;
38         desc->size = size;
39         if (size)
40                 decode_tree_entry(desc, buffer, size);
41 }
42
43 void *fill_tree_descriptor(struct tree_desc *desc, const unsigned char *sha1)
44 {
45         unsigned long size = 0;
46         void *buf = NULL;
47
48         if (sha1) {
49                 buf = read_object_with_reference(sha1, tree_type, &size, NULL);
50                 if (!buf)
51                         die("unable to read tree %s", sha1_to_hex(sha1));
52         }
53         init_tree_desc(desc, buf, size);
54         return buf;
55 }
56
57 static int entry_compare(struct name_entry *a, struct name_entry *b)
58 {
59         return base_name_compare(
60                         a->path, tree_entry_len(a->path, a->sha1), a->mode,
61                         b->path, tree_entry_len(b->path, b->sha1), b->mode);
62 }
63
64 static void entry_clear(struct name_entry *a)
65 {
66         memset(a, 0, sizeof(*a));
67 }
68
69 static void entry_extract(struct tree_desc *t, struct name_entry *a)
70 {
71         *a = t->entry;
72 }
73
74 void update_tree_entry(struct tree_desc *desc)
75 {
76         const void *buf = desc->buffer;
77         const unsigned char *end = desc->entry.sha1 + 20;
78         unsigned long size = desc->size;
79         unsigned long len = end - (const unsigned char *)buf;
80
81         if (size < len)
82                 die("corrupt tree file");
83         buf = end;
84         size -= len;
85         desc->buffer = buf;
86         desc->size = size;
87         if (size)
88                 decode_tree_entry(desc, buf, size);
89 }
90
91 int tree_entry(struct tree_desc *desc, struct name_entry *entry)
92 {
93         if (!desc->size)
94                 return 0;
95
96         *entry = desc->entry;
97         update_tree_entry(desc);
98         return 1;
99 }
100
101 void traverse_trees(int n, struct tree_desc *t, const char *base, traverse_callback_t callback)
102 {
103         struct name_entry *entry = xmalloc(n*sizeof(*entry));
104
105         for (;;) {
106                 unsigned long mask = 0;
107                 int i, last;
108
109                 last = -1;
110                 for (i = 0; i < n; i++) {
111                         if (!t[i].size)
112                                 continue;
113                         entry_extract(t+i, entry+i);
114                         if (last >= 0) {
115                                 int cmp = entry_compare(entry+i, entry+last);
116
117                                 /*
118                                  * Is the new name bigger than the old one?
119                                  * Ignore it
120                                  */
121                                 if (cmp > 0)
122                                         continue;
123                                 /*
124                                  * Is the new name smaller than the old one?
125                                  * Ignore all old ones
126                                  */
127                                 if (cmp < 0)
128                                         mask = 0;
129                         }
130                         mask |= 1ul << i;
131                         last = i;
132                 }
133                 if (!mask)
134                         break;
135
136                 /*
137                  * Update the tree entries we've walked, and clear
138                  * all the unused name-entries.
139                  */
140                 for (i = 0; i < n; i++) {
141                         if (mask & (1ul << i)) {
142                                 update_tree_entry(t+i);
143                                 continue;
144                         }
145                         entry_clear(entry + i);
146                 }
147                 callback(n, mask, entry, base);
148         }
149         free(entry);
150 }
151
152 static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char *result, unsigned *mode)
153 {
154         int namelen = strlen(name);
155         while (t->size) {
156                 const char *entry;
157                 const unsigned char *sha1;
158                 int entrylen, cmp;
159
160                 sha1 = tree_entry_extract(t, &entry, mode);
161                 update_tree_entry(t);
162                 entrylen = tree_entry_len(entry, sha1);
163                 if (entrylen > namelen)
164                         continue;
165                 cmp = memcmp(name, entry, entrylen);
166                 if (cmp > 0)
167                         continue;
168                 if (cmp < 0)
169                         break;
170                 if (entrylen == namelen) {
171                         hashcpy(result, sha1);
172                         return 0;
173                 }
174                 if (name[entrylen] != '/')
175                         continue;
176                 if (!S_ISDIR(*mode))
177                         break;
178                 if (++entrylen == namelen) {
179                         hashcpy(result, sha1);
180                         return 0;
181                 }
182                 return get_tree_entry(sha1, name + entrylen, result, mode);
183         }
184         return -1;
185 }
186
187 int get_tree_entry(const unsigned char *tree_sha1, const char *name, unsigned char *sha1, unsigned *mode)
188 {
189         int retval;
190         void *tree;
191         unsigned long size;
192         struct tree_desc t;
193         unsigned char root[20];
194
195         tree = read_object_with_reference(tree_sha1, tree_type, &size, root);
196         if (!tree)
197                 return -1;
198
199         if (name[0] == '\0') {
200                 hashcpy(sha1, root);
201                 return 0;
202         }
203
204         init_tree_desc(&t, tree, size);
205         retval = find_tree_entry(&t, name, sha1, mode);
206         free(tree);
207         return retval;
208 }
209