[PATCH] Add --diff-filter= output restriction to diff-* family.
[git.git] / delta.c
1 #include "object.h"
2 #include "blob.h"
3 #include "tree.h"
4 #include "commit.h"
5 #include "tag.h"
6 #include "delta.h"
7 #include "cache.h"
8
9 /* the delta object definition (it can alias any other object) */
10 struct delta {
11         union {
12                 struct object object;
13                 struct blob blob;
14                 struct tree tree;
15                 struct commit commit;
16                 struct tag tag;
17         } u;
18 };
19
20 struct delta *lookup_delta(const unsigned char *sha1)
21 {
22         struct object *obj = lookup_object(sha1);
23         if (!obj) {
24                 struct delta *ret = xmalloc(sizeof(struct delta));
25                 memset(ret, 0, sizeof(struct delta));
26                 created_object(sha1, &ret->u.object);
27                 return ret;
28         }
29         return (struct delta *) obj;
30 }
31
32 int parse_delta_buffer(struct delta *item, void *buffer, unsigned long size)
33 {
34         struct object *reference;
35         struct object_list *p;
36
37         if (item->u.object.delta)
38                 return 0;
39         item->u.object.delta = 1;
40         if (size <= 20)
41                 return -1;
42         reference = lookup_object(buffer);
43         if (!reference) {
44                 struct delta *ref = xmalloc(sizeof(struct delta));
45                 memset(ref, 0, sizeof(struct delta));
46                 created_object(buffer, &ref->u.object);
47                 reference = &ref->u.object;
48         }
49
50         p = xmalloc(sizeof(*p));
51         p->item = &item->u.object;
52         p->next = reference->attached_deltas;
53         reference->attached_deltas = p;
54         return 0;
55 }
56
57 int process_deltas(void *src, unsigned long src_size, const char *src_type,
58                    struct object_list *delta_list)
59 {
60         int deepest = 0;
61         do {
62                 struct object *obj = delta_list->item;
63                 static char type[10];
64                 void *map, *delta, *buf;
65                 unsigned long map_size, delta_size, buf_size;
66                 map = map_sha1_file(obj->sha1, &map_size);
67                 if (!map)
68                         continue;
69                 delta = unpack_sha1_file(map, map_size, type, &delta_size);
70                 munmap(map, map_size);
71                 if (!delta)
72                         continue;
73                 if (strcmp(type, "delta") || delta_size <= 20) {
74                         free(delta);
75                         continue;
76                 }
77                 buf = patch_delta(src, src_size,
78                                   delta+20, delta_size-20,
79                                   &buf_size);
80                 free(delta);
81                 if (!buf)
82                         continue;
83                 if (check_sha1_signature(obj->sha1, buf, buf_size, src_type) < 0)
84                         printf("sha1 mismatch for delta %s\n", sha1_to_hex(obj->sha1));
85                 if (obj->type && obj->type != src_type) {
86                         error("got %s when expecting %s for delta %s",
87                               src_type, obj->type, sha1_to_hex(obj->sha1));
88                         free(buf);
89                         continue;
90                 }
91                 obj->type = src_type;
92                 if (src_type == blob_type) {
93                         parse_blob_buffer((struct blob *)obj, buf, buf_size);
94                 } else if (src_type == tree_type) {
95                         parse_tree_buffer((struct tree *)obj, buf, buf_size);
96                 } else if (src_type == commit_type) {
97                         parse_commit_buffer((struct commit *)obj, buf, buf_size);
98                 } else if (src_type == tag_type) {
99                         parse_tag_buffer((struct tag *)obj, buf, buf_size);
100                 } else {
101                         error("unknown object type %s", src_type);
102                         free(buf);
103                         continue;
104                 }
105                 if (obj->attached_deltas) {
106                         int depth = process_deltas(buf, buf_size, src_type,
107                                                    obj->attached_deltas);
108                         if (deepest < depth)
109                                 deepest = depth;
110                 }
111                 free(buf);
112         } while ((delta_list = delta_list->next));
113         return deepest + 1;
114 }