@matheusbsbs / matheus-bagliano / commits / 53dda6ff62
Fork 0

teach git-index-pack about deltas with offset to base

Signed-off-by: Nicolas Pitre <nico@cam.org> Signed-off-by: Junio C Hamano <junkio@cox.net>

Nicolas Pitre committed Sep 21, 2006 at 00:08 UTC 53dda6ff6263a3f350514d9edae600468c946ed4
1 file changed +80 -31
index-pack.c
+80 -31
@@ -18,10 +18,15 @@ struct object_entry
18 unsigned char sha1[20];
19 };
20
21 +union delta_base {
22 + unsigned char sha1[20];
23 + unsigned long offset;
24 +};
25 +
26 struct delta_entry
27 {
28 struct object_entry *obj;
24 - unsigned char base_sha1[20];
29 + union delta_base base;
30 };
31
32 static const char *pack_name;
@@ -134,13 +139,13 @@ static void *unpack_entry_data(unsigned long offset,
139 static void *unpack_raw_entry(unsigned long offset,
140 enum object_type *obj_type,
141 unsigned long *obj_size,
137 - unsigned char *delta_base,
142 + union delta_base *delta_base,
143 unsigned long *next_obj_offset)
144 {
145 unsigned long pack_limit = pack_size - 20;
146 unsigned long pos = offset;
147 unsigned char c;
143 - unsigned long size;
148 + unsigned long size, base_offset;
149 unsigned shift;
150 enum object_type type;
151 void *data;
@@ -161,26 +166,43 @@ static void *unpack_raw_entry(unsigned long offset,
166 case OBJ_REF_DELTA:
167 if (pos + 20 >= pack_limit)
168 bad_object(offset, "object extends past end of pack");
164 - hashcpy(delta_base, pack_base + pos);
169 + hashcpy(delta_base->sha1, pack_base + pos);
170 pos += 20;
166 - /* fallthru */
171 + break;
172 + case OBJ_OFS_DELTA:
173 + memset(delta_base, 0, sizeof(*delta_base));
174 + c = pack_base[pos++];
175 + base_offset = c & 127;
176 + while (c & 128) {
177 + base_offset += 1;
178 + if (!base_offset || base_offset & ~(~0UL >> 7))
179 + bad_object(offset, "offset value overflow for delta base object");
180 + if (pos >= pack_limit)
181 + bad_object(offset, "object extends past end of pack");
182 + c = pack_base[pos++];
183 + base_offset = (base_offset << 7) + (c & 127);
184 + }
185 + delta_base->offset = offset - base_offset;
186 + if (delta_base->offset >= offset)
187 + bad_object(offset, "delta base offset is out of bound");
188 + break;
189 case OBJ_COMMIT:
190 case OBJ_TREE:
191 case OBJ_BLOB:
192 case OBJ_TAG:
171 - data = unpack_entry_data(offset, &pos, size);
193 break;
194 default:
195 bad_object(offset, "bad object type %d", type);
196 }
197
198 + data = unpack_entry_data(offset, &pos, size);
199 *obj_type = type;
200 *obj_size = size;
201 *next_obj_offset = pos;
202 return data;
203 }
204
183 -static int find_delta(const unsigned char *base_sha1)
205 +static int find_delta(const union delta_base *base)
206 {
207 int first = 0, last = nr_deltas;
208
@@ -189,7 +211,7 @@ static int find_delta(const unsigned char *base_sha1)
211 struct delta_entry *delta = &deltas[next];
212 int cmp;
213
192 - cmp = hashcmp(base_sha1, delta->base_sha1);
214 + cmp = memcmp(base, &delta->base, sizeof(*base));
215 if (!cmp)
216 return next;
217 if (cmp < 0) {
@@ -201,18 +223,18 @@ static int find_delta(const unsigned char *base_sha1)
223 return -first-1;
224 }
225
204 -static int find_deltas_based_on_sha1(const unsigned char *base_sha1,
205 - int *first_index, int *last_index)
226 +static int find_delta_childs(const union delta_base *base,
227 + int *first_index, int *last_index)
228 {
207 - int first = find_delta(base_sha1);
229 + int first = find_delta(base);
230 int last = first;
231 int end = nr_deltas - 1;
232
233 if (first < 0)
234 return -1;
213 - while (first > 0 && !hashcmp(deltas[first - 1].base_sha1, base_sha1))
235 + while (first > 0 && !memcmp(&deltas[first - 1].base, base, sizeof(*base)))
236 --first;
215 - while (last < end && !hashcmp(deltas[last + 1].base_sha1, base_sha1))
237 + while (last < end && !memcmp(&deltas[last + 1].base, base, sizeof(*base)))
238 ++last;
239 *first_index = first;
240 *last_index = last;
@@ -253,13 +275,13 @@ static void resolve_delta(struct delta_entry *delta, void *base_data,
275 void *result;
276 unsigned long result_size;
277 enum object_type delta_type;
256 - unsigned char base_sha1[20];
278 + union delta_base delta_base;
279 unsigned long next_obj_offset;
280 int j, first, last;
281
282 obj->real_type = type;
283 delta_data = unpack_raw_entry(obj->offset, &delta_type,
262 - &delta_size, base_sha1,
284 + &delta_size, &delta_base,
285 &next_obj_offset);
286 result = patch_delta(base_data, base_size, delta_data, delta_size,
287 &result_size);
@@ -267,10 +289,22 @@ static void resolve_delta(struct delta_entry *delta, void *base_data,
289 if (!result)
290 bad_object(obj->offset, "failed to apply delta");
291 sha1_object(result, result_size, type, obj->sha1);
270 - if (!find_deltas_based_on_sha1(obj->sha1, &first, &last)) {
292 +
293 + hashcpy(delta_base.sha1, obj->sha1);
294 + if (!find_delta_childs(&delta_base, &first, &last)) {
295 for (j = first; j <= last; j++)
272 - resolve_delta(&deltas[j], result, result_size, type);
296 + if (deltas[j].obj->type == OBJ_REF_DELTA)
297 + resolve_delta(&deltas[j], result, result_size, type);
298 }
299 +
300 + memset(&delta_base, 0, sizeof(delta_base));
301 + delta_base.offset = obj->offset;
302 + if (!find_delta_childs(&delta_base, &first, &last)) {
303 + for (j = first; j <= last; j++)
304 + if (deltas[j].obj->type == OBJ_OFS_DELTA)
305 + resolve_delta(&deltas[j], result, result_size, type);
306 + }
307 +
308 free(result);
309 }
310
@@ -278,14 +312,14 @@ static int compare_delta_entry(const void *a, const void *b)
312 {
313 const struct delta_entry *delta_a = a;
314 const struct delta_entry *delta_b = b;
281 - return hashcmp(delta_a->base_sha1, delta_b->base_sha1);
315 + return memcmp(&delta_a->base, &delta_b->base, sizeof(union delta_base));
316 }
317
318 static void parse_pack_objects(void)
319 {
320 int i;
321 unsigned long offset = sizeof(struct pack_header);
288 - unsigned char base_sha1[20];
322 + struct delta_entry *delta = deltas;
323 void *data;
324 unsigned long data_size;
325
@@ -299,12 +333,12 @@ static void parse_pack_objects(void)
333 struct object_entry *obj = &objects[i];
334 obj->offset = offset;
335 data = unpack_raw_entry(offset, &obj->type, &data_size,
302 - base_sha1, &offset);
336 + &delta->base, &offset);
337 obj->real_type = obj->type;
304 - if (obj->type == OBJ_REF_DELTA) {
305 - struct delta_entry *delta = &deltas[nr_deltas++];
338 + if (obj->type == OBJ_REF_DELTA || obj->type == OBJ_OFS_DELTA) {
339 + nr_deltas++;
340 delta->obj = obj;
307 - hashcpy(delta->base_sha1, base_sha1);
341 + delta++;
342 } else
343 sha1_object(data, data_size, obj->type, obj->sha1);
344 free(data);
@@ -312,7 +346,7 @@ static void parse_pack_objects(void)
346 if (offset != pack_size - 20)
347 die("packfile '%s' has junk at the end", pack_name);
348
315 - /* Sort deltas by base SHA1 for fast searching */
349 + /* Sort deltas by base SHA1/offset for fast searching */
350 qsort(deltas, nr_deltas, sizeof(struct delta_entry),
351 compare_delta_entry);
352
@@ -326,22 +360,37 @@ static void parse_pack_objects(void)
360 */
361 for (i = 0; i < nr_objects; i++) {
362 struct object_entry *obj = &objects[i];
329 - int j, first, last;
363 + union delta_base base;
364 + int j, ref, ref_first, ref_last, ofs, ofs_first, ofs_last;
365
331 - if (obj->type == OBJ_REF_DELTA)
366 + if (obj->type == OBJ_REF_DELTA || obj->type == OBJ_OFS_DELTA)
367 continue;
333 - if (find_deltas_based_on_sha1(obj->sha1, &first, &last))
368 + hashcpy(base.sha1, obj->sha1);
369 + ref = !find_delta_childs(&base, &ref_first, &ref_last);
370 + memset(&base, 0, sizeof(base));
371 + base.offset = obj->offset;
372 + ofs = !find_delta_childs(&base, &ofs_first, &ofs_last);
373 + if (!ref && !ofs)
374 continue;
375 data = unpack_raw_entry(obj->offset, &obj->type, &data_size,
336 - base_sha1, &offset);
337 - for (j = first; j <= last; j++)
338 - resolve_delta(&deltas[j], data, data_size, obj->type);
376 + &base, &offset);
377 + if (ref)
378 + for (j = ref_first; j <= ref_last; j++)
379 + if (deltas[j].obj->type == OBJ_REF_DELTA)
380 + resolve_delta(&deltas[j], data,
381 + data_size, obj->type);
382 + if (ofs)
383 + for (j = ofs_first; j <= ofs_last; j++)
384 + if (deltas[j].obj->type == OBJ_OFS_DELTA)
385 + resolve_delta(&deltas[j], data,
386 + data_size, obj->type);
387 free(data);
388 }
389
390 /* Check for unresolved deltas */
391 for (i = 0; i < nr_deltas; i++) {
344 - if (deltas[i].obj->real_type == OBJ_REF_DELTA)
392 + if (deltas[i].obj->real_type == OBJ_REF_DELTA ||
393 + deltas[i].obj->real_type == OBJ_OFS_DELTA)
394 die("packfile '%s' has unresolved deltas", pack_name);
395 }
396 }