]>
Commit | Line | Data |
---|---|---|
175785e5 DB |
1 | #include "tree.h" |
2 | #include "blob.h" | |
77675e2a DB |
3 | #include "commit.h" |
4 | #include "tag.h" | |
175785e5 DB |
5 | #include "cache.h" |
6 | #include <stdlib.h> | |
7 | ||
8 | const char *tree_type = "tree"; | |
9 | ||
94537c78 LT |
10 | static int read_one_entry(unsigned char *sha1, const char *base, int baselen, const char *pathname, unsigned mode, int stage) |
11 | { | |
3c5e8468 LT |
12 | int len; |
13 | unsigned int size; | |
14 | struct cache_entry *ce; | |
15 | ||
16 | if (S_ISDIR(mode)) | |
17 | return READ_TREE_RECURSIVE; | |
18 | ||
19 | len = strlen(pathname); | |
20 | size = cache_entry_size(baselen + len); | |
21 | ce = xmalloc(size); | |
94537c78 LT |
22 | |
23 | memset(ce, 0, size); | |
24 | ||
25 | ce->ce_mode = create_ce_mode(mode); | |
26 | ce->ce_flags = create_ce_flags(baselen + len, stage); | |
27 | memcpy(ce->name, base, baselen); | |
28 | memcpy(ce->name + baselen, pathname, len+1); | |
29 | memcpy(ce->sha1, sha1, 20); | |
b155725d | 30 | return add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK); |
94537c78 LT |
31 | } |
32 | ||
3e587635 | 33 | static int match_tree_entry(const char *base, int baselen, const char *path, unsigned int mode, const char **paths) |
0ca14a57 | 34 | { |
3e587635 | 35 | const char *match; |
0ca14a57 LT |
36 | int pathlen; |
37 | ||
38 | if (!paths) | |
39 | return 1; | |
40 | pathlen = strlen(path); | |
41 | while ((match = *paths++) != NULL) { | |
42 | int matchlen = strlen(match); | |
43 | ||
44 | if (baselen >= matchlen) { | |
45 | /* If it doesn't match, move along... */ | |
46 | if (strncmp(base, match, matchlen)) | |
47 | continue; | |
48 | /* The base is a subdirectory of a path which was specified. */ | |
49 | return 1; | |
50 | } | |
51 | ||
52 | /* Does the base match? */ | |
53 | if (strncmp(base, match, baselen)) | |
54 | continue; | |
55 | ||
56 | match += baselen; | |
57 | matchlen -= baselen; | |
58 | ||
59 | if (pathlen > matchlen) | |
60 | continue; | |
61 | ||
62 | if (matchlen > pathlen) { | |
63 | if (match[pathlen] != '/') | |
64 | continue; | |
65 | if (!S_ISDIR(mode)) | |
66 | continue; | |
67 | } | |
68 | ||
69 | if (strncmp(path, match, pathlen)) | |
70 | continue; | |
3e587635 LT |
71 | |
72 | return 1; | |
0ca14a57 LT |
73 | } |
74 | return 0; | |
75 | } | |
76 | ||
3c5e8468 LT |
77 | int read_tree_recursive(void *buffer, unsigned long size, |
78 | const char *base, int baselen, | |
79 | int stage, const char **match, | |
80 | read_tree_fn_t fn) | |
94537c78 LT |
81 | { |
82 | while (size) { | |
83 | int len = strlen(buffer)+1; | |
84 | unsigned char *sha1 = buffer + len; | |
85 | char *path = strchr(buffer, ' ')+1; | |
86 | unsigned int mode; | |
87 | ||
88 | if (size < len + 20 || sscanf(buffer, "%o", &mode) != 1) | |
89 | return -1; | |
90 | ||
91 | buffer = sha1 + 20; | |
92 | size -= len + 20; | |
93 | ||
0ca14a57 LT |
94 | if (!match_tree_entry(base, baselen, path, mode, match)) |
95 | continue; | |
96 | ||
3c5e8468 LT |
97 | switch (fn(sha1, base, baselen, path, mode, stage)) { |
98 | case 0: | |
99 | continue; | |
100 | case READ_TREE_RECURSIVE: | |
101 | break;; | |
102 | default: | |
103 | return -1; | |
104 | } | |
94537c78 LT |
105 | if (S_ISDIR(mode)) { |
106 | int retval; | |
107 | int pathlen = strlen(path); | |
1c9da46d | 108 | char *newbase; |
94537c78 LT |
109 | void *eltbuf; |
110 | char elttype[20]; | |
111 | unsigned long eltsize; | |
112 | ||
113 | eltbuf = read_sha1_file(sha1, elttype, &eltsize); | |
1c9da46d JF |
114 | if (!eltbuf || strcmp(elttype, "tree")) { |
115 | if (eltbuf) free(eltbuf); | |
94537c78 | 116 | return -1; |
1c9da46d JF |
117 | } |
118 | newbase = xmalloc(baselen + 1 + pathlen); | |
94537c78 LT |
119 | memcpy(newbase, base, baselen); |
120 | memcpy(newbase + baselen, path, pathlen); | |
121 | newbase[baselen + pathlen] = '/'; | |
122 | retval = read_tree_recursive(eltbuf, eltsize, | |
123 | newbase, | |
0ca14a57 | 124 | baselen + pathlen + 1, |
3c5e8468 | 125 | stage, match, fn); |
94537c78 LT |
126 | free(eltbuf); |
127 | free(newbase); | |
128 | if (retval) | |
129 | return -1; | |
130 | continue; | |
131 | } | |
94537c78 LT |
132 | } |
133 | return 0; | |
134 | } | |
135 | ||
3e587635 | 136 | int read_tree(void *buffer, unsigned long size, int stage, const char **match) |
94537c78 | 137 | { |
3c5e8468 | 138 | return read_tree_recursive(buffer, size, "", 0, stage, match, read_one_entry); |
94537c78 LT |
139 | } |
140 | ||
5d6ccf5c | 141 | struct tree *lookup_tree(const unsigned char *sha1) |
175785e5 DB |
142 | { |
143 | struct object *obj = lookup_object(sha1); | |
144 | if (!obj) { | |
812666c8 | 145 | struct tree *ret = xmalloc(sizeof(struct tree)); |
175785e5 DB |
146 | memset(ret, 0, sizeof(struct tree)); |
147 | created_object(sha1, &ret->object); | |
d32987be | 148 | ret->object.type = tree_type; |
175785e5 DB |
149 | return ret; |
150 | } | |
d1af002d NP |
151 | if (!obj->type) |
152 | obj->type = tree_type; | |
c35dfe85 | 153 | if (obj->type != tree_type) { |
175785e5 DB |
154 | error("Object %s is a %s, not a tree", |
155 | sha1_to_hex(sha1), obj->type); | |
156 | return NULL; | |
157 | } | |
158 | return (struct tree *) obj; | |
159 | } | |
160 | ||
bd2c39f5 | 161 | int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size) |
175785e5 | 162 | { |
bd2c39f5 | 163 | void *bufptr = buffer; |
08692164 | 164 | struct tree_entry_list **list_p; |
4a4e6fd7 | 165 | int n_refs = 0; |
bd2c39f5 | 166 | |
175785e5 DB |
167 | if (item->object.parsed) |
168 | return 0; | |
169 | item->object.parsed = 1; | |
08692164 | 170 | list_p = &item->entries; |
175785e5 DB |
171 | while (size) { |
172 | struct object *obj; | |
08692164 | 173 | struct tree_entry_list *entry; |
175785e5 DB |
174 | int len = 1+strlen(bufptr); |
175 | unsigned char *file_sha1 = bufptr + len; | |
176 | char *path = strchr(bufptr, ' '); | |
177 | unsigned int mode; | |
178 | if (size < len + 20 || !path || | |
bd2c39f5 | 179 | sscanf(bufptr, "%o", &mode) != 1) |
175785e5 DB |
180 | return -1; |
181 | ||
812666c8 | 182 | entry = xmalloc(sizeof(struct tree_entry_list)); |
08692164 | 183 | entry->name = strdup(path + 1); |
42ea9cb2 LT |
184 | entry->directory = S_ISDIR(mode) != 0; |
185 | entry->executable = (mode & S_IXUSR) != 0; | |
186 | entry->symlink = S_ISLNK(mode) != 0; | |
64071805 | 187 | entry->zeropad = *(char *)bufptr == '0'; |
42ea9cb2 | 188 | entry->mode = mode; |
08692164 DB |
189 | entry->next = NULL; |
190 | ||
175785e5 DB |
191 | bufptr += len + 20; |
192 | size -= len + 20; | |
193 | ||
08692164 DB |
194 | if (entry->directory) { |
195 | entry->item.tree = lookup_tree(file_sha1); | |
196 | obj = &entry->item.tree->object; | |
175785e5 | 197 | } else { |
08692164 DB |
198 | entry->item.blob = lookup_blob(file_sha1); |
199 | obj = &entry->item.blob->object; | |
175785e5 | 200 | } |
235ac407 | 201 | if (obj) |
4a4e6fd7 | 202 | n_refs++; |
08692164 DB |
203 | *list_p = entry; |
204 | list_p = &entry->next; | |
175785e5 | 205 | } |
4a4e6fd7 SV |
206 | |
207 | if (track_object_refs) { | |
208 | struct tree_entry_list *entry; | |
209 | unsigned i = 0; | |
210 | struct object_refs *refs = alloc_object_refs(n_refs); | |
211 | for (entry = item->entries; entry; entry = entry->next) | |
212 | refs->ref[i++] = entry->item.any; | |
213 | set_object_refs(&item->object, refs); | |
214 | } | |
215 | ||
175785e5 DB |
216 | return 0; |
217 | } | |
bd2c39f5 NP |
218 | |
219 | int parse_tree(struct tree *item) | |
220 | { | |
221 | char type[20]; | |
222 | void *buffer; | |
223 | unsigned long size; | |
224 | int ret; | |
225 | ||
226 | if (item->object.parsed) | |
227 | return 0; | |
228 | buffer = read_sha1_file(item->object.sha1, type, &size); | |
229 | if (!buffer) | |
230 | return error("Could not read %s", | |
231 | sha1_to_hex(item->object.sha1)); | |
232 | if (strcmp(type, tree_type)) { | |
233 | free(buffer); | |
234 | return error("Object %s not a tree", | |
235 | sha1_to_hex(item->object.sha1)); | |
236 | } | |
237 | ret = parse_tree_buffer(item, buffer, size); | |
238 | free(buffer); | |
239 | return ret; | |
240 | } | |
77675e2a DB |
241 | |
242 | struct tree *parse_tree_indirect(const unsigned char *sha1) | |
243 | { | |
244 | struct object *obj = parse_object(sha1); | |
245 | do { | |
246 | if (!obj) | |
247 | return NULL; | |
248 | if (obj->type == tree_type) | |
249 | return (struct tree *) obj; | |
250 | else if (obj->type == commit_type) | |
251 | obj = &(((struct commit *) obj)->tree->object); | |
252 | else if (obj->type == tag_type) | |
253 | obj = ((struct tag *) obj)->tagged; | |
254 | else | |
255 | return NULL; | |
256 | if (!obj->parsed) | |
257 | parse_object(obj->sha1); | |
258 | } while (1); | |
259 | } |