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
}