Merge branch 'jc/nobody-sets-src-peer-ref'
[git] / shallow.c
1 #include "cache.h"
2 #include "commit.h"
3 #include "tag.h"
4
5 static int is_shallow = -1;
6
7 int register_shallow(const unsigned char *sha1)
8 {
9         struct commit_graft *graft =
10                 xmalloc(sizeof(struct commit_graft));
11         struct commit *commit = lookup_commit(sha1);
12
13         hashcpy(graft->sha1, sha1);
14         graft->nr_parent = -1;
15         if (commit && commit->object.parsed)
16                 commit->parents = NULL;
17         return register_commit_graft(graft, 0);
18 }
19
20 int is_repository_shallow(void)
21 {
22         FILE *fp;
23         char buf[1024];
24
25         if (is_shallow >= 0)
26                 return is_shallow;
27
28         fp = fopen(git_path("shallow"), "r");
29         if (!fp) {
30                 is_shallow = 0;
31                 return is_shallow;
32         }
33         is_shallow = 1;
34
35         while (fgets(buf, sizeof(buf), fp)) {
36                 unsigned char sha1[20];
37                 if (get_sha1_hex(buf, sha1))
38                         die("bad shallow line: %s", buf);
39                 register_shallow(sha1);
40         }
41         fclose(fp);
42         return is_shallow;
43 }
44
45 struct commit_list *get_shallow_commits(struct object_array *heads, int depth,
46                 int shallow_flag, int not_shallow_flag)
47 {
48         int i = 0, cur_depth = 0;
49         struct commit_list *result = NULL;
50         struct object_array stack = OBJECT_ARRAY_INIT;
51         struct commit *commit = NULL;
52
53         while (commit || i < heads->nr || stack.nr) {
54                 struct commit_list *p;
55                 if (!commit) {
56                         if (i < heads->nr) {
57                                 commit = (struct commit *)
58                                         deref_tag(heads->objects[i++].item, NULL, 0);
59                                 if (!commit || commit->object.type != OBJ_COMMIT) {
60                                         commit = NULL;
61                                         continue;
62                                 }
63                                 if (!commit->util)
64                                         commit->util = xmalloc(sizeof(int));
65                                 *(int *)commit->util = 0;
66                                 cur_depth = 0;
67                         } else {
68                                 commit = (struct commit *)
69                                         stack.objects[--stack.nr].item;
70                                 cur_depth = *(int *)commit->util;
71                         }
72                 }
73                 if (parse_commit(commit))
74                         die("invalid commit");
75                 cur_depth++;
76                 if (cur_depth >= depth) {
77                         commit_list_insert(commit, &result);
78                         commit->object.flags |= shallow_flag;
79                         commit = NULL;
80                         continue;
81                 }
82                 commit->object.flags |= not_shallow_flag;
83                 for (p = commit->parents, commit = NULL; p; p = p->next) {
84                         if (!p->item->util) {
85                                 int *pointer = xmalloc(sizeof(int));
86                                 p->item->util = pointer;
87                                 *pointer =  cur_depth;
88                         } else {
89                                 int *pointer = p->item->util;
90                                 if (cur_depth >= *pointer)
91                                         continue;
92                                 *pointer = cur_depth;
93                         }
94                         if (cur_depth < depth) {
95                                 if (p->next)
96                                         add_object_array(&p->item->object,
97                                                         NULL, &stack);
98                                 else {
99                                         commit = p->item;
100                                         cur_depth = *(int *)commit->util;
101                                 }
102                         } else {
103                                 commit_list_insert(p->item, &result);
104                                 p->item->object.flags |= shallow_flag;
105                         }
106                 }
107         }
108
109         return result;
110 }