Use 'trash directory' thoroughly in t/test-lib.sh
[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         if (*str == ' ')
11                 return NULL;
12
13         while ((c = *str++) != ' ') {
14                 if (c < '0' || c > '7')
15                         return NULL;
16                 mode = (mode << 3) + (c - '0');
17         }
18         *modep = mode;
19         return str;
20 }
21
22 static void decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size)
23 {
24         const char *path;
25         unsigned int mode, len;
26
27         if (size < 24 || buf[size - 21])
28                 die("corrupt tree file");
29
30         path = get_mode(buf, &mode);
31         if (!path || !*path)
32                 die("corrupt tree file");
33         len = strlen(path) + 1;
34
35         /* Initialize the descriptor entry */
36         desc->entry.path = path;
37         desc->entry.mode = mode;
38         desc->entry.sha1 = (const unsigned char *)(path + len);
39 }
40
41 void init_tree_desc(struct tree_desc *desc, const void *buffer, unsigned long size)
42 {
43         desc->buffer = buffer;
44         desc->size = size;
45         if (size)
46                 decode_tree_entry(desc, buffer, size);
47 }
48
49 void *fill_tree_descriptor(struct tree_desc *desc, const unsigned char *sha1)
50 {
51         unsigned long size = 0;
52         void *buf = NULL;
53
54         if (sha1) {
55                 buf = read_object_with_reference(sha1, tree_type, &size, NULL);
56                 if (!buf)
57                         die("unable to read tree %s", sha1_to_hex(sha1));
58         }
59         init_tree_desc(desc, buf, size);
60         return buf;
61 }
62
63 static int entry_compare(struct name_entry *a, struct name_entry *b)
64 {
65         return df_name_compare(
66                         a->path, tree_entry_len(a->path, a->sha1), a->mode,
67                         b->path, tree_entry_len(b->path, b->sha1), b->mode);
68 }
69
70 static void entry_clear(struct name_entry *a)
71 {
72         memset(a, 0, sizeof(*a));
73 }
74
75 static void entry_extract(struct tree_desc *t, struct name_entry *a)
76 {
77         *a = t->entry;
78 }
79
80 void update_tree_entry(struct tree_desc *desc)
81 {
82         const void *buf = desc->buffer;
83         const unsigned char *end = desc->entry.sha1 + 20;
84         unsigned long size = desc->size;
85         unsigned long len = end - (const unsigned char *)buf;
86
87         if (size < len)
88                 die("corrupt tree file");
89         buf = end;
90         size -= len;
91         desc->buffer = buf;
92         desc->size = size;
93         if (size)
94                 decode_tree_entry(desc, buf, size);
95 }
96
97 int tree_entry(struct tree_desc *desc, struct name_entry *entry)
98 {
99         if (!desc->size)
100                 return 0;
101
102         *entry = desc->entry;
103         update_tree_entry(desc);
104         return 1;
105 }
106
107 void setup_traverse_info(struct traverse_info *info, const char *base)
108 {
109         int pathlen = strlen(base);
110         static struct traverse_info dummy;
111
112         memset(info, 0, sizeof(*info));
113         if (pathlen && base[pathlen-1] == '/')
114                 pathlen--;
115         info->pathlen = pathlen ? pathlen + 1 : 0;
116         info->name.path = base;
117         info->name.sha1 = (void *)(base + pathlen + 1);
118         if (pathlen)
119                 info->prev = &dummy;
120 }
121
122 char *make_traverse_path(char *path, const struct traverse_info *info, const struct name_entry *n)
123 {
124         int len = tree_entry_len(n->path, n->sha1);
125         int pathlen = info->pathlen;
126
127         path[pathlen + len] = 0;
128         for (;;) {
129                 memcpy(path + pathlen, n->path, len);
130                 if (!pathlen)
131                         break;
132                 path[--pathlen] = '/';
133                 n = &info->name;
134                 len = tree_entry_len(n->path, n->sha1);
135                 info = info->prev;
136                 pathlen -= len;
137         }
138         return path;
139 }
140
141 int traverse_trees(int n, struct tree_desc *t, struct traverse_info *info)
142 {
143         int ret = 0;
144         struct name_entry *entry = xmalloc(n*sizeof(*entry));
145
146         for (;;) {
147                 unsigned long mask = 0;
148                 unsigned long dirmask = 0;
149                 int i, last;
150
151                 last = -1;
152                 for (i = 0; i < n; i++) {
153                         if (!t[i].size)
154                                 continue;
155                         entry_extract(t+i, entry+i);
156                         if (last >= 0) {
157                                 int cmp = entry_compare(entry+i, entry+last);
158
159                                 /*
160                                  * Is the new name bigger than the old one?
161                                  * Ignore it
162                                  */
163                                 if (cmp > 0)
164                                         continue;
165                                 /*
166                                  * Is the new name smaller than the old one?
167                                  * Ignore all old ones
168                                  */
169                                 if (cmp < 0)
170                                         mask = 0;
171                         }
172                         mask |= 1ul << i;
173                         if (S_ISDIR(entry[i].mode))
174                                 dirmask |= 1ul << i;
175                         last = i;
176                 }
177                 if (!mask)
178                         break;
179                 dirmask &= mask;
180
181                 /*
182                  * Clear all the unused name-entries.
183                  */
184                 for (i = 0; i < n; i++) {
185                         if (mask & (1ul << i))
186                                 continue;
187                         entry_clear(entry + i);
188                 }
189                 ret = info->fn(n, mask, dirmask, entry, info);
190                 if (ret < 0)
191                         break;
192                 if (ret)
193                         mask &= ret;
194                 ret = 0;
195                 for (i = 0; i < n; i++) {
196                         if (mask & (1ul << i))
197                                 update_tree_entry(t + i);
198                 }
199         }
200         free(entry);
201         return ret;
202 }
203
204 static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char *result, unsigned *mode)
205 {
206         int namelen = strlen(name);
207         while (t->size) {
208                 const char *entry;
209                 const unsigned char *sha1;
210                 int entrylen, cmp;
211
212                 sha1 = tree_entry_extract(t, &entry, mode);
213                 update_tree_entry(t);
214                 entrylen = tree_entry_len(entry, sha1);
215                 if (entrylen > namelen)
216                         continue;
217                 cmp = memcmp(name, entry, entrylen);
218                 if (cmp > 0)
219                         continue;
220                 if (cmp < 0)
221                         break;
222                 if (entrylen == namelen) {
223                         hashcpy(result, sha1);
224                         return 0;
225                 }
226                 if (name[entrylen] != '/')
227                         continue;
228                 if (!S_ISDIR(*mode))
229                         break;
230                 if (++entrylen == namelen) {
231                         hashcpy(result, sha1);
232                         return 0;
233                 }
234                 return get_tree_entry(sha1, name + entrylen, result, mode);
235         }
236         return -1;
237 }
238
239 int get_tree_entry(const unsigned char *tree_sha1, const char *name, unsigned char *sha1, unsigned *mode)
240 {
241         int retval;
242         void *tree;
243         unsigned long size;
244         struct tree_desc t;
245         unsigned char root[20];
246
247         tree = read_object_with_reference(tree_sha1, tree_type, &size, root);
248         if (!tree)
249                 return -1;
250
251         if (name[0] == '\0') {
252                 hashcpy(sha1, root);
253                 return 0;
254         }
255
256         init_tree_desc(&t, tree, size);
257         retval = find_tree_entry(&t, name, sha1, mode);
258         free(tree);
259         return retval;
260 }