Merge branch 'jl/submodule-status-failure-report'
[git] / vcs-svn / repo_tree.c
1 /*
2  * Licensed under a two-clause BSD-style license.
3  * See LICENSE for details.
4  */
5
6 #include "git-compat-util.h"
7
8 #include "string_pool.h"
9 #include "repo_tree.h"
10 #include "obj_pool.h"
11 #include "fast_export.h"
12
13 #include "trp.h"
14
15 struct repo_dirent {
16         uint32_t name_offset;
17         struct trp_node children;
18         uint32_t mode;
19         uint32_t content_offset;
20 };
21
22 struct repo_dir {
23         struct trp_root entries;
24 };
25
26 struct repo_commit {
27         uint32_t root_dir_offset;
28 };
29
30 /* Memory pools for commit, dir and dirent */
31 obj_pool_gen(commit, struct repo_commit, 4096)
32 obj_pool_gen(dir, struct repo_dir, 4096)
33 obj_pool_gen(dent, struct repo_dirent, 4096)
34
35 static uint32_t active_commit;
36 static uint32_t mark;
37
38 static int repo_dirent_name_cmp(const void *a, const void *b);
39
40 /* Treap for directory entries */
41 trp_gen(static, dent_, struct repo_dirent, children, dent, repo_dirent_name_cmp)
42
43 uint32_t next_blob_mark(void)
44 {
45         return mark++;
46 }
47
48 static struct repo_dir *repo_commit_root_dir(struct repo_commit *commit)
49 {
50         return dir_pointer(commit->root_dir_offset);
51 }
52
53 static struct repo_dirent *repo_first_dirent(struct repo_dir *dir)
54 {
55         return dent_first(&dir->entries);
56 }
57
58 static int repo_dirent_name_cmp(const void *a, const void *b)
59 {
60         const struct repo_dirent *dent1 = a, *dent2 = b;
61         uint32_t a_offset = dent1->name_offset;
62         uint32_t b_offset = dent2->name_offset;
63         return (a_offset > b_offset) - (a_offset < b_offset);
64 }
65
66 static int repo_dirent_is_dir(struct repo_dirent *dent)
67 {
68         return dent != NULL && dent->mode == REPO_MODE_DIR;
69 }
70
71 static struct repo_dir *repo_dir_from_dirent(struct repo_dirent *dent)
72 {
73         if (!repo_dirent_is_dir(dent))
74                 return NULL;
75         return dir_pointer(dent->content_offset);
76 }
77
78 static struct repo_dir *repo_clone_dir(struct repo_dir *orig_dir)
79 {
80         uint32_t orig_o, new_o;
81         orig_o = dir_offset(orig_dir);
82         if (orig_o >= dir_pool.committed)
83                 return orig_dir;
84         new_o = dir_alloc(1);
85         orig_dir = dir_pointer(orig_o);
86         *dir_pointer(new_o) = *orig_dir;
87         return dir_pointer(new_o);
88 }
89
90 static struct repo_dirent *repo_read_dirent(uint32_t revision,
91                                             const uint32_t *path)
92 {
93         uint32_t name = 0;
94         struct repo_dirent *key = dent_pointer(dent_alloc(1));
95         struct repo_dir *dir = NULL;
96         struct repo_dirent *dent = NULL;
97         dir = repo_commit_root_dir(commit_pointer(revision));
98         while (~(name = *path++)) {
99                 key->name_offset = name;
100                 dent = dent_search(&dir->entries, key);
101                 if (dent == NULL || !repo_dirent_is_dir(dent))
102                         break;
103                 dir = repo_dir_from_dirent(dent);
104         }
105         dent_free(1);
106         return dent;
107 }
108
109 static void repo_write_dirent(const uint32_t *path, uint32_t mode,
110                               uint32_t content_offset, uint32_t del)
111 {
112         uint32_t name, revision, dir_o = ~0, parent_dir_o = ~0;
113         struct repo_dir *dir;
114         struct repo_dirent *key;
115         struct repo_dirent *dent = NULL;
116         revision = active_commit;
117         dir = repo_commit_root_dir(commit_pointer(revision));
118         dir = repo_clone_dir(dir);
119         commit_pointer(revision)->root_dir_offset = dir_offset(dir);
120         while (~(name = *path++)) {
121                 parent_dir_o = dir_offset(dir);
122
123                 key = dent_pointer(dent_alloc(1));
124                 key->name_offset = name;
125
126                 dent = dent_search(&dir->entries, key);
127                 if (dent == NULL)
128                         dent = key;
129                 else
130                         dent_free(1);
131
132                 if (dent == key) {
133                         dent->mode = REPO_MODE_DIR;
134                         dent->content_offset = 0;
135                         dent = dent_insert(&dir->entries, dent);
136                 }
137
138                 if (dent_offset(dent) < dent_pool.committed) {
139                         dir_o = repo_dirent_is_dir(dent) ?
140                                         dent->content_offset : ~0;
141                         dent_remove(&dir->entries, dent);
142                         dent = dent_pointer(dent_alloc(1));
143                         dent->name_offset = name;
144                         dent->mode = REPO_MODE_DIR;
145                         dent->content_offset = dir_o;
146                         dent = dent_insert(&dir->entries, dent);
147                 }
148
149                 dir = repo_dir_from_dirent(dent);
150                 dir = repo_clone_dir(dir);
151                 dent->content_offset = dir_offset(dir);
152         }
153         if (dent == NULL)
154                 return;
155         dent->mode = mode;
156         dent->content_offset = content_offset;
157         if (del && ~parent_dir_o)
158                 dent_remove(&dir_pointer(parent_dir_o)->entries, dent);
159 }
160
161 uint32_t repo_read_path(const uint32_t *path)
162 {
163         uint32_t content_offset = 0;
164         struct repo_dirent *dent = repo_read_dirent(active_commit, path);
165         if (dent != NULL)
166                 content_offset = dent->content_offset;
167         return content_offset;
168 }
169
170 uint32_t repo_read_mode(const uint32_t *path)
171 {
172         struct repo_dirent *dent = repo_read_dirent(active_commit, path);
173         if (dent == NULL)
174                 die("invalid dump: path to be modified is missing");
175         return dent->mode;
176 }
177
178 void repo_copy(uint32_t revision, const uint32_t *src, const uint32_t *dst)
179 {
180         uint32_t mode = 0, content_offset = 0;
181         struct repo_dirent *src_dent;
182         src_dent = repo_read_dirent(revision, src);
183         if (src_dent != NULL) {
184                 mode = src_dent->mode;
185                 content_offset = src_dent->content_offset;
186                 repo_write_dirent(dst, mode, content_offset, 0);
187         }
188 }
189
190 void repo_add(uint32_t *path, uint32_t mode, uint32_t blob_mark)
191 {
192         repo_write_dirent(path, mode, blob_mark, 0);
193 }
194
195 void repo_delete(uint32_t *path)
196 {
197         repo_write_dirent(path, 0, 0, 1);
198 }
199
200 static void repo_git_add_r(uint32_t depth, uint32_t *path, struct repo_dir *dir);
201
202 static void repo_git_add(uint32_t depth, uint32_t *path, struct repo_dirent *dent)
203 {
204         if (repo_dirent_is_dir(dent))
205                 repo_git_add_r(depth, path, repo_dir_from_dirent(dent));
206         else
207                 fast_export_modify(depth, path,
208                                    dent->mode, dent->content_offset);
209 }
210
211 static void repo_git_add_r(uint32_t depth, uint32_t *path, struct repo_dir *dir)
212 {
213         struct repo_dirent *de = repo_first_dirent(dir);
214         while (de) {
215                 path[depth] = de->name_offset;
216                 repo_git_add(depth + 1, path, de);
217                 de = dent_next(&dir->entries, de);
218         }
219 }
220
221 static void repo_diff_r(uint32_t depth, uint32_t *path, struct repo_dir *dir1,
222                         struct repo_dir *dir2)
223 {
224         struct repo_dirent *de1, *de2;
225         de1 = repo_first_dirent(dir1);
226         de2 = repo_first_dirent(dir2);
227
228         while (de1 && de2) {
229                 if (de1->name_offset < de2->name_offset) {
230                         path[depth] = de1->name_offset;
231                         fast_export_delete(depth + 1, path);
232                         de1 = dent_next(&dir1->entries, de1);
233                         continue;
234                 }
235                 if (de1->name_offset > de2->name_offset) {
236                         path[depth] = de2->name_offset;
237                         repo_git_add(depth + 1, path, de2);
238                         de2 = dent_next(&dir2->entries, de2);
239                         continue;
240                 }
241                 path[depth] = de1->name_offset;
242
243                 if (de1->mode == de2->mode &&
244                     de1->content_offset == de2->content_offset) {
245                         ; /* No change. */
246                 } else if (repo_dirent_is_dir(de1) && repo_dirent_is_dir(de2)) {
247                         repo_diff_r(depth + 1, path,
248                                     repo_dir_from_dirent(de1),
249                                     repo_dir_from_dirent(de2));
250                 } else if (!repo_dirent_is_dir(de1) && !repo_dirent_is_dir(de2)) {
251                         repo_git_add(depth + 1, path, de2);
252                 } else {
253                         fast_export_delete(depth + 1, path);
254                         repo_git_add(depth + 1, path, de2);
255                 }
256                 de1 = dent_next(&dir1->entries, de1);
257                 de2 = dent_next(&dir2->entries, de2);
258         }
259         while (de1) {
260                 path[depth] = de1->name_offset;
261                 fast_export_delete(depth + 1, path);
262                 de1 = dent_next(&dir1->entries, de1);
263         }
264         while (de2) {
265                 path[depth] = de2->name_offset;
266                 repo_git_add(depth + 1, path, de2);
267                 de2 = dent_next(&dir2->entries, de2);
268         }
269 }
270
271 static uint32_t path_stack[REPO_MAX_PATH_DEPTH];
272
273 void repo_diff(uint32_t r1, uint32_t r2)
274 {
275         repo_diff_r(0,
276                     path_stack,
277                     repo_commit_root_dir(commit_pointer(r1)),
278                     repo_commit_root_dir(commit_pointer(r2)));
279 }
280
281 void repo_commit(uint32_t revision, const char *author,
282                 const struct strbuf *log, const char *uuid, const char *url,
283                 unsigned long timestamp)
284 {
285         fast_export_commit(revision, author, log, uuid, url, timestamp);
286         dent_commit();
287         dir_commit();
288         active_commit = commit_alloc(1);
289         commit_pointer(active_commit)->root_dir_offset =
290                 commit_pointer(active_commit - 1)->root_dir_offset;
291 }
292
293 static void mark_init(void)
294 {
295         uint32_t i;
296         mark = 0;
297         for (i = 0; i < dent_pool.size; i++)
298                 if (!repo_dirent_is_dir(dent_pointer(i)) &&
299                     dent_pointer(i)->content_offset > mark)
300                         mark = dent_pointer(i)->content_offset;
301         mark++;
302 }
303
304 void repo_init(void)
305 {
306         mark_init();
307         if (commit_pool.size == 0) {
308                 /* Create empty tree for commit 0. */
309                 commit_alloc(1);
310                 commit_pointer(0)->root_dir_offset = dir_alloc(1);
311                 dir_pointer(0)->entries.trp_root = ~0;
312                 dir_commit();
313         }
314         /* Preallocate next commit, ready for changes. */
315         active_commit = commit_alloc(1);
316         commit_pointer(active_commit)->root_dir_offset =
317                 commit_pointer(active_commit - 1)->root_dir_offset;
318 }
319
320 void repo_reset(void)
321 {
322         pool_reset();
323         commit_reset();
324         dir_reset();
325         dent_reset();
326 }