##// END OF EJS Templates
lazymanifest: drop SP before some labels...
Martin von Zweigbergk -
r24975:89c2bf63 default
parent child Browse files
Show More
@@ -1,921 +1,921 b''
1 /*
1 /*
2 * manifest.c - manifest type that does on-demand parsing.
2 * manifest.c - manifest type that does on-demand parsing.
3 *
3 *
4 * Copyright 2015, Google Inc.
4 * Copyright 2015, Google Inc.
5 *
5 *
6 * This software may be used and distributed according to the terms of
6 * This software may be used and distributed according to the terms of
7 * the GNU General Public License, incorporated herein by reference.
7 * the GNU General Public License, incorporated herein by reference.
8 */
8 */
9 #include <Python.h>
9 #include <Python.h>
10
10
11 #include <assert.h>
11 #include <assert.h>
12 #include <string.h>
12 #include <string.h>
13 #include <stdlib.h>
13 #include <stdlib.h>
14
14
15 #include "util.h"
15 #include "util.h"
16
16
17 #define DEFAULT_LINES 100000
17 #define DEFAULT_LINES 100000
18
18
19 typedef struct {
19 typedef struct {
20 char *start;
20 char *start;
21 Py_ssize_t len; /* length of line including terminal newline */
21 Py_ssize_t len; /* length of line including terminal newline */
22 char hash_suffix;
22 char hash_suffix;
23 bool from_malloc;
23 bool from_malloc;
24 bool deleted;
24 bool deleted;
25 } line;
25 } line;
26
26
27 typedef struct {
27 typedef struct {
28 PyObject_HEAD
28 PyObject_HEAD
29 PyObject *pydata;
29 PyObject *pydata;
30 line *lines;
30 line *lines;
31 int numlines; /* number of line entries */
31 int numlines; /* number of line entries */
32 int livelines; /* number of non-deleted lines */
32 int livelines; /* number of non-deleted lines */
33 int maxlines; /* allocated number of lines */
33 int maxlines; /* allocated number of lines */
34 bool dirty;
34 bool dirty;
35 } lazymanifest;
35 } lazymanifest;
36
36
37 #define MANIFEST_OOM -1
37 #define MANIFEST_OOM -1
38 #define MANIFEST_NOT_SORTED -2
38 #define MANIFEST_NOT_SORTED -2
39 #define MANIFEST_MALFORMED -3
39 #define MANIFEST_MALFORMED -3
40
40
41 /* defined in parsers.c */
41 /* defined in parsers.c */
42 PyObject *unhexlify(const char *str, int len);
42 PyObject *unhexlify(const char *str, int len);
43
43
44 /* get the length of the path for a line */
44 /* get the length of the path for a line */
45 static size_t pathlen(line *l) {
45 static size_t pathlen(line *l) {
46 return strlen(l->start);
46 return strlen(l->start);
47 }
47 }
48
48
49 /* get the node value of a single line */
49 /* get the node value of a single line */
50 static PyObject *nodeof(line *l) {
50 static PyObject *nodeof(line *l) {
51 char *s = l->start;
51 char *s = l->start;
52 ssize_t llen = pathlen(l);
52 ssize_t llen = pathlen(l);
53 PyObject *hash = unhexlify(s + llen + 1, 40);
53 PyObject *hash = unhexlify(s + llen + 1, 40);
54 if (!hash) {
54 if (!hash) {
55 return NULL;
55 return NULL;
56 }
56 }
57 if (l->hash_suffix != '\0') {
57 if (l->hash_suffix != '\0') {
58 char newhash[21];
58 char newhash[21];
59 memcpy(newhash, PyString_AsString(hash), 20);
59 memcpy(newhash, PyString_AsString(hash), 20);
60 Py_DECREF(hash);
60 Py_DECREF(hash);
61 newhash[20] = l->hash_suffix;
61 newhash[20] = l->hash_suffix;
62 hash = PyString_FromStringAndSize(newhash, 21);
62 hash = PyString_FromStringAndSize(newhash, 21);
63 }
63 }
64 return hash;
64 return hash;
65 }
65 }
66
66
67 /* get the node hash and flags of a line as a tuple */
67 /* get the node hash and flags of a line as a tuple */
68 static PyObject *hashflags(line *l)
68 static PyObject *hashflags(line *l)
69 {
69 {
70 char *s = l->start;
70 char *s = l->start;
71 size_t plen = pathlen(l);
71 size_t plen = pathlen(l);
72 PyObject *hash = nodeof(l);
72 PyObject *hash = nodeof(l);
73
73
74 /* 40 for hash, 1 for null byte, 1 for newline */
74 /* 40 for hash, 1 for null byte, 1 for newline */
75 size_t hplen = plen + 42;
75 size_t hplen = plen + 42;
76 Py_ssize_t flen = l->len - hplen;
76 Py_ssize_t flen = l->len - hplen;
77 PyObject *flags;
77 PyObject *flags;
78 PyObject *tup;
78 PyObject *tup;
79
79
80 if (!hash)
80 if (!hash)
81 return NULL;
81 return NULL;
82 flags = PyString_FromStringAndSize(s + hplen - 1, flen);
82 flags = PyString_FromStringAndSize(s + hplen - 1, flen);
83 if (!flags) {
83 if (!flags) {
84 Py_DECREF(hash);
84 Py_DECREF(hash);
85 return NULL;
85 return NULL;
86 }
86 }
87 tup = PyTuple_Pack(2, hash, flags);
87 tup = PyTuple_Pack(2, hash, flags);
88 Py_DECREF(flags);
88 Py_DECREF(flags);
89 Py_DECREF(hash);
89 Py_DECREF(hash);
90 return tup;
90 return tup;
91 }
91 }
92
92
93 /* if we're about to run out of space in the line index, add more */
93 /* if we're about to run out of space in the line index, add more */
94 static bool realloc_if_full(lazymanifest *self)
94 static bool realloc_if_full(lazymanifest *self)
95 {
95 {
96 if (self->numlines == self->maxlines) {
96 if (self->numlines == self->maxlines) {
97 self->maxlines *= 2;
97 self->maxlines *= 2;
98 self->lines = realloc(self->lines, self->maxlines * sizeof(line));
98 self->lines = realloc(self->lines, self->maxlines * sizeof(line));
99 }
99 }
100 return !!self->lines;
100 return !!self->lines;
101 }
101 }
102
102
103 /*
103 /*
104 * Find the line boundaries in the manifest that 'data' points to and store
104 * Find the line boundaries in the manifest that 'data' points to and store
105 * information about each line in 'self'.
105 * information about each line in 'self'.
106 */
106 */
107 static int find_lines(lazymanifest *self, char *data, Py_ssize_t len)
107 static int find_lines(lazymanifest *self, char *data, Py_ssize_t len)
108 {
108 {
109 char *prev = NULL;
109 char *prev = NULL;
110 while (len > 0) {
110 while (len > 0) {
111 line *l;
111 line *l;
112 char *next = memchr(data, '\n', len);
112 char *next = memchr(data, '\n', len);
113 if (!next) {
113 if (!next) {
114 return MANIFEST_MALFORMED;
114 return MANIFEST_MALFORMED;
115 }
115 }
116 next++; /* advance past newline */
116 next++; /* advance past newline */
117 if (!realloc_if_full(self)) {
117 if (!realloc_if_full(self)) {
118 return MANIFEST_OOM; /* no memory */
118 return MANIFEST_OOM; /* no memory */
119 }
119 }
120 if (prev && strcmp(prev, data) > -1) {
120 if (prev && strcmp(prev, data) > -1) {
121 /* This data isn't sorted, so we have to abort. */
121 /* This data isn't sorted, so we have to abort. */
122 return MANIFEST_NOT_SORTED;
122 return MANIFEST_NOT_SORTED;
123 }
123 }
124 l = self->lines + ((self->numlines)++);
124 l = self->lines + ((self->numlines)++);
125 l->start = data;
125 l->start = data;
126 l->len = next - data;
126 l->len = next - data;
127 l->hash_suffix = '\0';
127 l->hash_suffix = '\0';
128 l->from_malloc = false;
128 l->from_malloc = false;
129 l->deleted = false;
129 l->deleted = false;
130 len = len - l->len;
130 len = len - l->len;
131 prev = data;
131 prev = data;
132 data = next;
132 data = next;
133 }
133 }
134 self->livelines = self->numlines;
134 self->livelines = self->numlines;
135 return 0;
135 return 0;
136 }
136 }
137
137
138 static int lazymanifest_init(lazymanifest *self, PyObject *args)
138 static int lazymanifest_init(lazymanifest *self, PyObject *args)
139 {
139 {
140 char *data;
140 char *data;
141 Py_ssize_t len;
141 Py_ssize_t len;
142 int err, ret;
142 int err, ret;
143 PyObject *pydata;
143 PyObject *pydata;
144 if (!PyArg_ParseTuple(args, "S", &pydata)) {
144 if (!PyArg_ParseTuple(args, "S", &pydata)) {
145 return -1;
145 return -1;
146 }
146 }
147 err = PyString_AsStringAndSize(pydata, &data, &len);
147 err = PyString_AsStringAndSize(pydata, &data, &len);
148
148
149 self->dirty = false;
149 self->dirty = false;
150 if (err == -1)
150 if (err == -1)
151 return -1;
151 return -1;
152 self->pydata = pydata;
152 self->pydata = pydata;
153 Py_INCREF(self->pydata);
153 Py_INCREF(self->pydata);
154 Py_BEGIN_ALLOW_THREADS
154 Py_BEGIN_ALLOW_THREADS
155 self->lines = malloc(DEFAULT_LINES * sizeof(line));
155 self->lines = malloc(DEFAULT_LINES * sizeof(line));
156 self->maxlines = DEFAULT_LINES;
156 self->maxlines = DEFAULT_LINES;
157 self->numlines = 0;
157 self->numlines = 0;
158 if (!self->lines)
158 if (!self->lines)
159 ret = MANIFEST_OOM;
159 ret = MANIFEST_OOM;
160 else
160 else
161 ret = find_lines(self, data, len);
161 ret = find_lines(self, data, len);
162 Py_END_ALLOW_THREADS
162 Py_END_ALLOW_THREADS
163 switch (ret) {
163 switch (ret) {
164 case 0:
164 case 0:
165 break;
165 break;
166 case MANIFEST_OOM:
166 case MANIFEST_OOM:
167 PyErr_NoMemory();
167 PyErr_NoMemory();
168 break;
168 break;
169 case MANIFEST_NOT_SORTED:
169 case MANIFEST_NOT_SORTED:
170 PyErr_Format(PyExc_ValueError,
170 PyErr_Format(PyExc_ValueError,
171 "Manifest lines not in sorted order.");
171 "Manifest lines not in sorted order.");
172 break;
172 break;
173 case MANIFEST_MALFORMED:
173 case MANIFEST_MALFORMED:
174 PyErr_Format(PyExc_ValueError,
174 PyErr_Format(PyExc_ValueError,
175 "Manifest did not end in a newline.");
175 "Manifest did not end in a newline.");
176 break;
176 break;
177 default:
177 default:
178 PyErr_Format(PyExc_ValueError,
178 PyErr_Format(PyExc_ValueError,
179 "Unknown problem parsing manifest.");
179 "Unknown problem parsing manifest.");
180 }
180 }
181 return ret == 0 ? 0 : -1;
181 return ret == 0 ? 0 : -1;
182 }
182 }
183
183
184 static void lazymanifest_dealloc(lazymanifest *self)
184 static void lazymanifest_dealloc(lazymanifest *self)
185 {
185 {
186 /* free any extra lines we had to allocate */
186 /* free any extra lines we had to allocate */
187 int i;
187 int i;
188 for (i = 0; i < self->numlines; i++) {
188 for (i = 0; i < self->numlines; i++) {
189 if (self->lines[i].from_malloc) {
189 if (self->lines[i].from_malloc) {
190 free(self->lines[i].start);
190 free(self->lines[i].start);
191 }
191 }
192 }
192 }
193 if (self->lines) {
193 if (self->lines) {
194 free(self->lines);
194 free(self->lines);
195 self->lines = NULL;
195 self->lines = NULL;
196 }
196 }
197 if (self->pydata) {
197 if (self->pydata) {
198 Py_DECREF(self->pydata);
198 Py_DECREF(self->pydata);
199 self->pydata = NULL;
199 self->pydata = NULL;
200 }
200 }
201 PyObject_Del(self);
201 PyObject_Del(self);
202 }
202 }
203
203
204 /* iteration support */
204 /* iteration support */
205
205
206 typedef struct {
206 typedef struct {
207 PyObject_HEAD lazymanifest *m;
207 PyObject_HEAD lazymanifest *m;
208 Py_ssize_t pos;
208 Py_ssize_t pos;
209 } lmIter;
209 } lmIter;
210
210
211 static void lmiter_dealloc(PyObject *o)
211 static void lmiter_dealloc(PyObject *o)
212 {
212 {
213 lmIter *self = (lmIter *)o;
213 lmIter *self = (lmIter *)o;
214 Py_DECREF(self->m);
214 Py_DECREF(self->m);
215 PyObject_Del(self);
215 PyObject_Del(self);
216 }
216 }
217
217
218 static line *lmiter_nextline(lmIter *self)
218 static line *lmiter_nextline(lmIter *self)
219 {
219 {
220 do {
220 do {
221 self->pos++;
221 self->pos++;
222 if (self->pos >= self->m->numlines) {
222 if (self->pos >= self->m->numlines) {
223 return NULL;
223 return NULL;
224 }
224 }
225 /* skip over deleted manifest entries */
225 /* skip over deleted manifest entries */
226 } while (self->m->lines[self->pos].deleted);
226 } while (self->m->lines[self->pos].deleted);
227 return self->m->lines + self->pos;
227 return self->m->lines + self->pos;
228 }
228 }
229
229
230 static PyObject *lmiter_iterentriesnext(PyObject *o)
230 static PyObject *lmiter_iterentriesnext(PyObject *o)
231 {
231 {
232 size_t pl;
232 size_t pl;
233 line *l;
233 line *l;
234 Py_ssize_t consumed;
234 Py_ssize_t consumed;
235 PyObject *ret = NULL, *path = NULL, *hash = NULL, *flags = NULL;
235 PyObject *ret = NULL, *path = NULL, *hash = NULL, *flags = NULL;
236 l = lmiter_nextline((lmIter *)o);
236 l = lmiter_nextline((lmIter *)o);
237 if (!l) {
237 if (!l) {
238 goto done;
238 goto done;
239 }
239 }
240 pl = pathlen(l);
240 pl = pathlen(l);
241 path = PyString_FromStringAndSize(l->start, pl);
241 path = PyString_FromStringAndSize(l->start, pl);
242 hash = nodeof(l);
242 hash = nodeof(l);
243 consumed = pl + 41;
243 consumed = pl + 41;
244 flags = PyString_FromStringAndSize(l->start + consumed,
244 flags = PyString_FromStringAndSize(l->start + consumed,
245 l->len - consumed - 1);
245 l->len - consumed - 1);
246 if (!path || !hash || !flags) {
246 if (!path || !hash || !flags) {
247 goto done;
247 goto done;
248 }
248 }
249 ret = PyTuple_Pack(3, path, hash, flags);
249 ret = PyTuple_Pack(3, path, hash, flags);
250 done:
250 done:
251 Py_XDECREF(path);
251 Py_XDECREF(path);
252 Py_XDECREF(hash);
252 Py_XDECREF(hash);
253 Py_XDECREF(flags);
253 Py_XDECREF(flags);
254 return ret;
254 return ret;
255 }
255 }
256
256
257 static PyTypeObject lazymanifestEntriesIterator = {
257 static PyTypeObject lazymanifestEntriesIterator = {
258 PyObject_HEAD_INIT(NULL)
258 PyObject_HEAD_INIT(NULL)
259 0, /*ob_size */
259 0, /*ob_size */
260 "parsers.lazymanifest.entriesiterator", /*tp_name */
260 "parsers.lazymanifest.entriesiterator", /*tp_name */
261 sizeof(lmIter), /*tp_basicsize */
261 sizeof(lmIter), /*tp_basicsize */
262 0, /*tp_itemsize */
262 0, /*tp_itemsize */
263 lmiter_dealloc, /*tp_dealloc */
263 lmiter_dealloc, /*tp_dealloc */
264 0, /*tp_print */
264 0, /*tp_print */
265 0, /*tp_getattr */
265 0, /*tp_getattr */
266 0, /*tp_setattr */
266 0, /*tp_setattr */
267 0, /*tp_compare */
267 0, /*tp_compare */
268 0, /*tp_repr */
268 0, /*tp_repr */
269 0, /*tp_as_number */
269 0, /*tp_as_number */
270 0, /*tp_as_sequence */
270 0, /*tp_as_sequence */
271 0, /*tp_as_mapping */
271 0, /*tp_as_mapping */
272 0, /*tp_hash */
272 0, /*tp_hash */
273 0, /*tp_call */
273 0, /*tp_call */
274 0, /*tp_str */
274 0, /*tp_str */
275 0, /*tp_getattro */
275 0, /*tp_getattro */
276 0, /*tp_setattro */
276 0, /*tp_setattro */
277 0, /*tp_as_buffer */
277 0, /*tp_as_buffer */
278 /* tp_flags: Py_TPFLAGS_HAVE_ITER tells python to
278 /* tp_flags: Py_TPFLAGS_HAVE_ITER tells python to
279 use tp_iter and tp_iternext fields. */
279 use tp_iter and tp_iternext fields. */
280 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,
280 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,
281 "Iterator for 3-tuples in a lazymanifest.", /* tp_doc */
281 "Iterator for 3-tuples in a lazymanifest.", /* tp_doc */
282 0, /* tp_traverse */
282 0, /* tp_traverse */
283 0, /* tp_clear */
283 0, /* tp_clear */
284 0, /* tp_richcompare */
284 0, /* tp_richcompare */
285 0, /* tp_weaklistoffset */
285 0, /* tp_weaklistoffset */
286 PyObject_SelfIter, /* tp_iter: __iter__() method */
286 PyObject_SelfIter, /* tp_iter: __iter__() method */
287 lmiter_iterentriesnext, /* tp_iternext: next() method */
287 lmiter_iterentriesnext, /* tp_iternext: next() method */
288 };
288 };
289
289
290 static PyObject *lmiter_iterkeysnext(PyObject *o)
290 static PyObject *lmiter_iterkeysnext(PyObject *o)
291 {
291 {
292 size_t pl;
292 size_t pl;
293 line *l = lmiter_nextline((lmIter *)o);
293 line *l = lmiter_nextline((lmIter *)o);
294 if (!l) {
294 if (!l) {
295 return NULL;
295 return NULL;
296 }
296 }
297 pl = pathlen(l);
297 pl = pathlen(l);
298 return PyString_FromStringAndSize(l->start, pl);
298 return PyString_FromStringAndSize(l->start, pl);
299 }
299 }
300
300
301 static PyTypeObject lazymanifestKeysIterator = {
301 static PyTypeObject lazymanifestKeysIterator = {
302 PyObject_HEAD_INIT(NULL)
302 PyObject_HEAD_INIT(NULL)
303 0, /*ob_size */
303 0, /*ob_size */
304 "parsers.lazymanifest.keysiterator", /*tp_name */
304 "parsers.lazymanifest.keysiterator", /*tp_name */
305 sizeof(lmIter), /*tp_basicsize */
305 sizeof(lmIter), /*tp_basicsize */
306 0, /*tp_itemsize */
306 0, /*tp_itemsize */
307 lmiter_dealloc, /*tp_dealloc */
307 lmiter_dealloc, /*tp_dealloc */
308 0, /*tp_print */
308 0, /*tp_print */
309 0, /*tp_getattr */
309 0, /*tp_getattr */
310 0, /*tp_setattr */
310 0, /*tp_setattr */
311 0, /*tp_compare */
311 0, /*tp_compare */
312 0, /*tp_repr */
312 0, /*tp_repr */
313 0, /*tp_as_number */
313 0, /*tp_as_number */
314 0, /*tp_as_sequence */
314 0, /*tp_as_sequence */
315 0, /*tp_as_mapping */
315 0, /*tp_as_mapping */
316 0, /*tp_hash */
316 0, /*tp_hash */
317 0, /*tp_call */
317 0, /*tp_call */
318 0, /*tp_str */
318 0, /*tp_str */
319 0, /*tp_getattro */
319 0, /*tp_getattro */
320 0, /*tp_setattro */
320 0, /*tp_setattro */
321 0, /*tp_as_buffer */
321 0, /*tp_as_buffer */
322 /* tp_flags: Py_TPFLAGS_HAVE_ITER tells python to
322 /* tp_flags: Py_TPFLAGS_HAVE_ITER tells python to
323 use tp_iter and tp_iternext fields. */
323 use tp_iter and tp_iternext fields. */
324 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,
324 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,
325 "Keys iterator for a lazymanifest.", /* tp_doc */
325 "Keys iterator for a lazymanifest.", /* tp_doc */
326 0, /* tp_traverse */
326 0, /* tp_traverse */
327 0, /* tp_clear */
327 0, /* tp_clear */
328 0, /* tp_richcompare */
328 0, /* tp_richcompare */
329 0, /* tp_weaklistoffset */
329 0, /* tp_weaklistoffset */
330 PyObject_SelfIter, /* tp_iter: __iter__() method */
330 PyObject_SelfIter, /* tp_iter: __iter__() method */
331 lmiter_iterkeysnext, /* tp_iternext: next() method */
331 lmiter_iterkeysnext, /* tp_iternext: next() method */
332 };
332 };
333
333
334 static lazymanifest *lazymanifest_copy(lazymanifest *self);
334 static lazymanifest *lazymanifest_copy(lazymanifest *self);
335
335
336 static PyObject *lazymanifest_getentriesiter(lazymanifest *self)
336 static PyObject *lazymanifest_getentriesiter(lazymanifest *self)
337 {
337 {
338 lmIter *i = NULL;
338 lmIter *i = NULL;
339 lazymanifest *t = lazymanifest_copy(self);
339 lazymanifest *t = lazymanifest_copy(self);
340 if (!t) {
340 if (!t) {
341 PyErr_NoMemory();
341 PyErr_NoMemory();
342 return NULL;
342 return NULL;
343 }
343 }
344 i = PyObject_New(lmIter, &lazymanifestEntriesIterator);
344 i = PyObject_New(lmIter, &lazymanifestEntriesIterator);
345 if (i) {
345 if (i) {
346 i->m = t;
346 i->m = t;
347 i->pos = -1;
347 i->pos = -1;
348 } else {
348 } else {
349 Py_DECREF(t);
349 Py_DECREF(t);
350 PyErr_NoMemory();
350 PyErr_NoMemory();
351 }
351 }
352 return (PyObject *)i;
352 return (PyObject *)i;
353 }
353 }
354
354
355 static PyObject *lazymanifest_getkeysiter(lazymanifest *self)
355 static PyObject *lazymanifest_getkeysiter(lazymanifest *self)
356 {
356 {
357 lmIter *i = NULL;
357 lmIter *i = NULL;
358 lazymanifest *t = lazymanifest_copy(self);
358 lazymanifest *t = lazymanifest_copy(self);
359 if (!t) {
359 if (!t) {
360 PyErr_NoMemory();
360 PyErr_NoMemory();
361 return NULL;
361 return NULL;
362 }
362 }
363 i = PyObject_New(lmIter, &lazymanifestKeysIterator);
363 i = PyObject_New(lmIter, &lazymanifestKeysIterator);
364 if (i) {
364 if (i) {
365 i->m = t;
365 i->m = t;
366 i->pos = -1;
366 i->pos = -1;
367 } else {
367 } else {
368 Py_DECREF(t);
368 Py_DECREF(t);
369 PyErr_NoMemory();
369 PyErr_NoMemory();
370 }
370 }
371 return (PyObject *)i;
371 return (PyObject *)i;
372 }
372 }
373
373
374 /* __getitem__ and __setitem__ support */
374 /* __getitem__ and __setitem__ support */
375
375
376 static Py_ssize_t lazymanifest_size(lazymanifest *self)
376 static Py_ssize_t lazymanifest_size(lazymanifest *self)
377 {
377 {
378 return self->livelines;
378 return self->livelines;
379 }
379 }
380
380
381 static int linecmp(const void *left, const void *right)
381 static int linecmp(const void *left, const void *right)
382 {
382 {
383 return strcmp(((const line *)left)->start,
383 return strcmp(((const line *)left)->start,
384 ((const line *)right)->start);
384 ((const line *)right)->start);
385 }
385 }
386
386
387 static PyObject *lazymanifest_getitem(lazymanifest *self, PyObject *key)
387 static PyObject *lazymanifest_getitem(lazymanifest *self, PyObject *key)
388 {
388 {
389 line needle;
389 line needle;
390 line *hit;
390 line *hit;
391 if (!PyString_Check(key)) {
391 if (!PyString_Check(key)) {
392 PyErr_Format(PyExc_TypeError,
392 PyErr_Format(PyExc_TypeError,
393 "getitem: manifest keys must be a string.");
393 "getitem: manifest keys must be a string.");
394 return NULL;
394 return NULL;
395 }
395 }
396 needle.start = PyString_AsString(key);
396 needle.start = PyString_AsString(key);
397 hit = bsearch(&needle, self->lines, self->numlines, sizeof(line),
397 hit = bsearch(&needle, self->lines, self->numlines, sizeof(line),
398 &linecmp);
398 &linecmp);
399 if (!hit || hit->deleted) {
399 if (!hit || hit->deleted) {
400 PyErr_Format(PyExc_KeyError, "No such manifest entry.");
400 PyErr_Format(PyExc_KeyError, "No such manifest entry.");
401 return NULL;
401 return NULL;
402 }
402 }
403 return hashflags(hit);
403 return hashflags(hit);
404 }
404 }
405
405
406 static int lazymanifest_delitem(lazymanifest *self, PyObject *key)
406 static int lazymanifest_delitem(lazymanifest *self, PyObject *key)
407 {
407 {
408 line needle;
408 line needle;
409 line *hit;
409 line *hit;
410 if (!PyString_Check(key)) {
410 if (!PyString_Check(key)) {
411 PyErr_Format(PyExc_TypeError,
411 PyErr_Format(PyExc_TypeError,
412 "delitem: manifest keys must be a string.");
412 "delitem: manifest keys must be a string.");
413 return -1;
413 return -1;
414 }
414 }
415 needle.start = PyString_AsString(key);
415 needle.start = PyString_AsString(key);
416 hit = bsearch(&needle, self->lines, self->numlines, sizeof(line),
416 hit = bsearch(&needle, self->lines, self->numlines, sizeof(line),
417 &linecmp);
417 &linecmp);
418 if (!hit || hit->deleted) {
418 if (!hit || hit->deleted) {
419 PyErr_Format(PyExc_KeyError,
419 PyErr_Format(PyExc_KeyError,
420 "Tried to delete nonexistent manifest entry.");
420 "Tried to delete nonexistent manifest entry.");
421 return -1;
421 return -1;
422 }
422 }
423 self->dirty = true;
423 self->dirty = true;
424 hit->deleted = true;
424 hit->deleted = true;
425 self->livelines--;
425 self->livelines--;
426 return 0;
426 return 0;
427 }
427 }
428
428
429 /* Do a binary search for the insertion point for new, creating the
429 /* Do a binary search for the insertion point for new, creating the
430 * new entry if needed. */
430 * new entry if needed. */
431 static int internalsetitem(lazymanifest *self, line *new) {
431 static int internalsetitem(lazymanifest *self, line *new) {
432 int start = 0, end = self->numlines;
432 int start = 0, end = self->numlines;
433 while (start < end) {
433 while (start < end) {
434 int pos = start + (end - start) / 2;
434 int pos = start + (end - start) / 2;
435 int c = linecmp(new, self->lines + pos);
435 int c = linecmp(new, self->lines + pos);
436 if (c < 0)
436 if (c < 0)
437 end = pos;
437 end = pos;
438 else if (c > 0)
438 else if (c > 0)
439 start = pos + 1;
439 start = pos + 1;
440 else {
440 else {
441 if (self->lines[pos].deleted)
441 if (self->lines[pos].deleted)
442 self->livelines++;
442 self->livelines++;
443 if (self->lines[pos].from_malloc)
443 if (self->lines[pos].from_malloc)
444 free(self->lines[pos].start);
444 free(self->lines[pos].start);
445 start = pos;
445 start = pos;
446 goto finish;
446 goto finish;
447 }
447 }
448 }
448 }
449 /* being here means we need to do an insert */
449 /* being here means we need to do an insert */
450 if (!realloc_if_full(self)) {
450 if (!realloc_if_full(self)) {
451 PyErr_NoMemory();
451 PyErr_NoMemory();
452 return -1;
452 return -1;
453 }
453 }
454 memmove(self->lines + start + 1, self->lines + start,
454 memmove(self->lines + start + 1, self->lines + start,
455 (self->numlines - start) * sizeof(line));
455 (self->numlines - start) * sizeof(line));
456 self->numlines++;
456 self->numlines++;
457 self->livelines++;
457 self->livelines++;
458 finish:
458 finish:
459 self->lines[start] = *new;
459 self->lines[start] = *new;
460 self->dirty = true;
460 self->dirty = true;
461 return 0;
461 return 0;
462 }
462 }
463
463
464 static int lazymanifest_setitem(
464 static int lazymanifest_setitem(
465 lazymanifest *self, PyObject *key, PyObject *value)
465 lazymanifest *self, PyObject *key, PyObject *value)
466 {
466 {
467 char *path;
467 char *path;
468 Py_ssize_t plen;
468 Py_ssize_t plen;
469 PyObject *pyhash;
469 PyObject *pyhash;
470 Py_ssize_t hlen;
470 Py_ssize_t hlen;
471 char *hash;
471 char *hash;
472 PyObject *pyflags;
472 PyObject *pyflags;
473 char *flags;
473 char *flags;
474 Py_ssize_t flen;
474 Py_ssize_t flen;
475 size_t dlen;
475 size_t dlen;
476 char *dest;
476 char *dest;
477 int i;
477 int i;
478 line new;
478 line new;
479 if (!PyString_Check(key)) {
479 if (!PyString_Check(key)) {
480 PyErr_Format(PyExc_TypeError,
480 PyErr_Format(PyExc_TypeError,
481 "setitem: manifest keys must be a string.");
481 "setitem: manifest keys must be a string.");
482 return -1;
482 return -1;
483 }
483 }
484 if (!value) {
484 if (!value) {
485 return lazymanifest_delitem(self, key);
485 return lazymanifest_delitem(self, key);
486 }
486 }
487 if (!PyTuple_Check(value) || PyTuple_Size(value) != 2) {
487 if (!PyTuple_Check(value) || PyTuple_Size(value) != 2) {
488 PyErr_Format(PyExc_TypeError,
488 PyErr_Format(PyExc_TypeError,
489 "Manifest values must be a tuple of (node, flags).");
489 "Manifest values must be a tuple of (node, flags).");
490 return -1;
490 return -1;
491 }
491 }
492 if (PyString_AsStringAndSize(key, &path, &plen) == -1) {
492 if (PyString_AsStringAndSize(key, &path, &plen) == -1) {
493 return -1;
493 return -1;
494 }
494 }
495
495
496 pyhash = PyTuple_GetItem(value, 0);
496 pyhash = PyTuple_GetItem(value, 0);
497 if (!PyString_Check(pyhash)) {
497 if (!PyString_Check(pyhash)) {
498 PyErr_Format(PyExc_TypeError,
498 PyErr_Format(PyExc_TypeError,
499 "node must be a 20-byte string");
499 "node must be a 20-byte string");
500 return -1;
500 return -1;
501 }
501 }
502 hlen = PyString_Size(pyhash);
502 hlen = PyString_Size(pyhash);
503 /* Some parts of the codebase try and set 21 or 22
503 /* Some parts of the codebase try and set 21 or 22
504 * byte "hash" values in order to perturb things for
504 * byte "hash" values in order to perturb things for
505 * status. We have to preserve at least the 21st
505 * status. We have to preserve at least the 21st
506 * byte. Sigh. If there's a 22nd byte, we drop it on
506 * byte. Sigh. If there's a 22nd byte, we drop it on
507 * the floor, which works fine.
507 * the floor, which works fine.
508 */
508 */
509 if (hlen != 20 && hlen != 21 && hlen != 22) {
509 if (hlen != 20 && hlen != 21 && hlen != 22) {
510 PyErr_Format(PyExc_TypeError,
510 PyErr_Format(PyExc_TypeError,
511 "node must be a 20-byte string");
511 "node must be a 20-byte string");
512 return -1;
512 return -1;
513 }
513 }
514 hash = PyString_AsString(pyhash);
514 hash = PyString_AsString(pyhash);
515
515
516 pyflags = PyTuple_GetItem(value, 1);
516 pyflags = PyTuple_GetItem(value, 1);
517 if (!PyString_Check(pyflags) || PyString_Size(pyflags) > 1) {
517 if (!PyString_Check(pyflags) || PyString_Size(pyflags) > 1) {
518 PyErr_Format(PyExc_TypeError,
518 PyErr_Format(PyExc_TypeError,
519 "flags must a 0 or 1 byte string");
519 "flags must a 0 or 1 byte string");
520 return -1;
520 return -1;
521 }
521 }
522 if (PyString_AsStringAndSize(pyflags, &flags, &flen) == -1) {
522 if (PyString_AsStringAndSize(pyflags, &flags, &flen) == -1) {
523 return -1;
523 return -1;
524 }
524 }
525 /* one null byte and one newline */
525 /* one null byte and one newline */
526 dlen = plen + 41 + flen + 1;
526 dlen = plen + 41 + flen + 1;
527 dest = malloc(dlen);
527 dest = malloc(dlen);
528 if (!dest) {
528 if (!dest) {
529 PyErr_NoMemory();
529 PyErr_NoMemory();
530 return -1;
530 return -1;
531 }
531 }
532 memcpy(dest, path, plen + 1);
532 memcpy(dest, path, plen + 1);
533 for (i = 0; i < 20; i++) {
533 for (i = 0; i < 20; i++) {
534 /* Cast to unsigned, so it will not get sign-extended when promoted
534 /* Cast to unsigned, so it will not get sign-extended when promoted
535 * to int (as is done when passing to a variadic function)
535 * to int (as is done when passing to a variadic function)
536 */
536 */
537 sprintf(dest + plen + 1 + (i * 2), "%02x", (unsigned char)hash[i]);
537 sprintf(dest + plen + 1 + (i * 2), "%02x", (unsigned char)hash[i]);
538 }
538 }
539 memcpy(dest + plen + 41, flags, flen);
539 memcpy(dest + plen + 41, flags, flen);
540 dest[plen + 41 + flen] = '\n';
540 dest[plen + 41 + flen] = '\n';
541 new.start = dest;
541 new.start = dest;
542 new.len = dlen;
542 new.len = dlen;
543 new.hash_suffix = '\0';
543 new.hash_suffix = '\0';
544 if (hlen > 20) {
544 if (hlen > 20) {
545 new.hash_suffix = hash[20];
545 new.hash_suffix = hash[20];
546 }
546 }
547 new.from_malloc = true; /* is `start` a pointer we allocated? */
547 new.from_malloc = true; /* is `start` a pointer we allocated? */
548 new.deleted = false; /* is this entry deleted? */
548 new.deleted = false; /* is this entry deleted? */
549 if (internalsetitem(self, &new)) {
549 if (internalsetitem(self, &new)) {
550 return -1;
550 return -1;
551 }
551 }
552 return 0;
552 return 0;
553 }
553 }
554
554
555 static PyMappingMethods lazymanifest_mapping_methods = {
555 static PyMappingMethods lazymanifest_mapping_methods = {
556 (lenfunc)lazymanifest_size, /* mp_length */
556 (lenfunc)lazymanifest_size, /* mp_length */
557 (binaryfunc)lazymanifest_getitem, /* mp_subscript */
557 (binaryfunc)lazymanifest_getitem, /* mp_subscript */
558 (objobjargproc)lazymanifest_setitem, /* mp_ass_subscript */
558 (objobjargproc)lazymanifest_setitem, /* mp_ass_subscript */
559 };
559 };
560
560
561 /* sequence methods (important or __contains__ builds an iterator */
561 /* sequence methods (important or __contains__ builds an iterator */
562
562
563 static int lazymanifest_contains(lazymanifest *self, PyObject *key)
563 static int lazymanifest_contains(lazymanifest *self, PyObject *key)
564 {
564 {
565 line needle;
565 line needle;
566 line *hit;
566 line *hit;
567 if (!PyString_Check(key)) {
567 if (!PyString_Check(key)) {
568 /* Our keys are always strings, so if the contains
568 /* Our keys are always strings, so if the contains
569 * check is for a non-string, just return false. */
569 * check is for a non-string, just return false. */
570 return 0;
570 return 0;
571 }
571 }
572 needle.start = PyString_AsString(key);
572 needle.start = PyString_AsString(key);
573 hit = bsearch(&needle, self->lines, self->numlines, sizeof(line),
573 hit = bsearch(&needle, self->lines, self->numlines, sizeof(line),
574 &linecmp);
574 &linecmp);
575 if (!hit || hit->deleted) {
575 if (!hit || hit->deleted) {
576 return 0;
576 return 0;
577 }
577 }
578 return 1;
578 return 1;
579 }
579 }
580
580
581 static PySequenceMethods lazymanifest_seq_meths = {
581 static PySequenceMethods lazymanifest_seq_meths = {
582 (lenfunc)lazymanifest_size, /* sq_length */
582 (lenfunc)lazymanifest_size, /* sq_length */
583 0, /* sq_concat */
583 0, /* sq_concat */
584 0, /* sq_repeat */
584 0, /* sq_repeat */
585 0, /* sq_item */
585 0, /* sq_item */
586 0, /* sq_slice */
586 0, /* sq_slice */
587 0, /* sq_ass_item */
587 0, /* sq_ass_item */
588 0, /* sq_ass_slice */
588 0, /* sq_ass_slice */
589 (objobjproc)lazymanifest_contains, /* sq_contains */
589 (objobjproc)lazymanifest_contains, /* sq_contains */
590 0, /* sq_inplace_concat */
590 0, /* sq_inplace_concat */
591 0, /* sq_inplace_repeat */
591 0, /* sq_inplace_repeat */
592 };
592 };
593
593
594
594
595 /* Other methods (copy, diff, etc) */
595 /* Other methods (copy, diff, etc) */
596 static PyTypeObject lazymanifestType;
596 static PyTypeObject lazymanifestType;
597
597
598 /* If the manifest has changes, build the new manifest text and reindex it. */
598 /* If the manifest has changes, build the new manifest text and reindex it. */
599 static int compact(lazymanifest *self) {
599 static int compact(lazymanifest *self) {
600 int i;
600 int i;
601 ssize_t need = 0;
601 ssize_t need = 0;
602 char *data;
602 char *data;
603 line *src, *dst;
603 line *src, *dst;
604 PyObject *pydata;
604 PyObject *pydata;
605 if (!self->dirty)
605 if (!self->dirty)
606 return 0;
606 return 0;
607 for (i = 0; i < self->numlines; i++) {
607 for (i = 0; i < self->numlines; i++) {
608 if (!self->lines[i].deleted) {
608 if (!self->lines[i].deleted) {
609 need += self->lines[i].len;
609 need += self->lines[i].len;
610 }
610 }
611 }
611 }
612 pydata = PyString_FromStringAndSize(NULL, need);
612 pydata = PyString_FromStringAndSize(NULL, need);
613 if (!pydata)
613 if (!pydata)
614 return -1;
614 return -1;
615 data = PyString_AsString(pydata);
615 data = PyString_AsString(pydata);
616 if (!data) {
616 if (!data) {
617 return -1;
617 return -1;
618 }
618 }
619 src = self->lines;
619 src = self->lines;
620 dst = self->lines;
620 dst = self->lines;
621 for (i = 0; i < self->numlines; i++, src++) {
621 for (i = 0; i < self->numlines; i++, src++) {
622 char *tofree = NULL;
622 char *tofree = NULL;
623 if (src->from_malloc) {
623 if (src->from_malloc) {
624 tofree = src->start;
624 tofree = src->start;
625 }
625 }
626 if (!src->deleted) {
626 if (!src->deleted) {
627 memcpy(data, src->start, src->len);
627 memcpy(data, src->start, src->len);
628 *dst = *src;
628 *dst = *src;
629 dst->start = data;
629 dst->start = data;
630 dst->from_malloc = false;
630 dst->from_malloc = false;
631 data += dst->len;
631 data += dst->len;
632 dst++;
632 dst++;
633 }
633 }
634 free(tofree);
634 free(tofree);
635 }
635 }
636 Py_DECREF(self->pydata);
636 Py_DECREF(self->pydata);
637 self->pydata = pydata;
637 self->pydata = pydata;
638 self->numlines = self->livelines;
638 self->numlines = self->livelines;
639 self->dirty = false;
639 self->dirty = false;
640 return 0;
640 return 0;
641 }
641 }
642
642
643 static PyObject *lazymanifest_text(lazymanifest *self)
643 static PyObject *lazymanifest_text(lazymanifest *self)
644 {
644 {
645 if (compact(self) != 0) {
645 if (compact(self) != 0) {
646 PyErr_NoMemory();
646 PyErr_NoMemory();
647 return NULL;
647 return NULL;
648 }
648 }
649 Py_INCREF(self->pydata);
649 Py_INCREF(self->pydata);
650 return self->pydata;
650 return self->pydata;
651 }
651 }
652
652
653 static lazymanifest *lazymanifest_copy(lazymanifest *self)
653 static lazymanifest *lazymanifest_copy(lazymanifest *self)
654 {
654 {
655 lazymanifest *copy = NULL;
655 lazymanifest *copy = NULL;
656 if (compact(self) != 0) {
656 if (compact(self) != 0) {
657 goto nomem;
657 goto nomem;
658 }
658 }
659 copy = PyObject_New(lazymanifest, &lazymanifestType);
659 copy = PyObject_New(lazymanifest, &lazymanifestType);
660 if (!copy) {
660 if (!copy) {
661 goto nomem;
661 goto nomem;
662 }
662 }
663 copy->numlines = self->numlines;
663 copy->numlines = self->numlines;
664 copy->livelines = self->livelines;
664 copy->livelines = self->livelines;
665 copy->dirty = false;
665 copy->dirty = false;
666 copy->lines = malloc(self->maxlines *sizeof(line));
666 copy->lines = malloc(self->maxlines *sizeof(line));
667 if (!copy->lines) {
667 if (!copy->lines) {
668 goto nomem;
668 goto nomem;
669 }
669 }
670 memcpy(copy->lines, self->lines, self->numlines * sizeof(line));
670 memcpy(copy->lines, self->lines, self->numlines * sizeof(line));
671 copy->maxlines = self->maxlines;
671 copy->maxlines = self->maxlines;
672 copy->pydata = self->pydata;
672 copy->pydata = self->pydata;
673 Py_INCREF(copy->pydata);
673 Py_INCREF(copy->pydata);
674 return copy;
674 return copy;
675 nomem:
675 nomem:
676 PyErr_NoMemory();
676 PyErr_NoMemory();
677 Py_XDECREF(copy);
677 Py_XDECREF(copy);
678 return NULL;
678 return NULL;
679 }
679 }
680
680
681 static lazymanifest *lazymanifest_filtercopy(
681 static lazymanifest *lazymanifest_filtercopy(
682 lazymanifest *self, PyObject *matchfn)
682 lazymanifest *self, PyObject *matchfn)
683 {
683 {
684 lazymanifest *copy = NULL;
684 lazymanifest *copy = NULL;
685 int i;
685 int i;
686 if (!PyCallable_Check(matchfn)) {
686 if (!PyCallable_Check(matchfn)) {
687 PyErr_SetString(PyExc_TypeError, "matchfn must be callable");
687 PyErr_SetString(PyExc_TypeError, "matchfn must be callable");
688 return NULL;
688 return NULL;
689 }
689 }
690 /* compact ourselves first to avoid double-frees later when we
690 /* compact ourselves first to avoid double-frees later when we
691 * compact tmp so that it doesn't have random pointers to our
691 * compact tmp so that it doesn't have random pointers to our
692 * underlying from_malloc-data (self->pydata is safe) */
692 * underlying from_malloc-data (self->pydata is safe) */
693 if (compact(self) != 0) {
693 if (compact(self) != 0) {
694 goto nomem;
694 goto nomem;
695 }
695 }
696 copy = PyObject_New(lazymanifest, &lazymanifestType);
696 copy = PyObject_New(lazymanifest, &lazymanifestType);
697 copy->dirty = true;
697 copy->dirty = true;
698 copy->lines = malloc(self->maxlines * sizeof(line));
698 copy->lines = malloc(self->maxlines * sizeof(line));
699 if (!copy->lines) {
699 if (!copy->lines) {
700 goto nomem;
700 goto nomem;
701 }
701 }
702 copy->maxlines = self->maxlines;
702 copy->maxlines = self->maxlines;
703 copy->numlines = 0;
703 copy->numlines = 0;
704 copy->pydata = self->pydata;
704 copy->pydata = self->pydata;
705 Py_INCREF(self->pydata);
705 Py_INCREF(self->pydata);
706 for (i = 0; i < self->numlines; i++) {
706 for (i = 0; i < self->numlines; i++) {
707 PyObject *arg = PyString_FromString(self->lines[i].start);
707 PyObject *arg = PyString_FromString(self->lines[i].start);
708 PyObject *arglist = PyTuple_Pack(1, arg);
708 PyObject *arglist = PyTuple_Pack(1, arg);
709 PyObject *result = PyObject_CallObject(matchfn, arglist);
709 PyObject *result = PyObject_CallObject(matchfn, arglist);
710 Py_DECREF(arglist);
710 Py_DECREF(arglist);
711 Py_DECREF(arg);
711 Py_DECREF(arg);
712 /* if the callback raised an exception, just let it
712 /* if the callback raised an exception, just let it
713 * through and give up */
713 * through and give up */
714 if (!result) {
714 if (!result) {
715 free(copy->lines);
715 free(copy->lines);
716 Py_DECREF(self->pydata);
716 Py_DECREF(self->pydata);
717 return NULL;
717 return NULL;
718 }
718 }
719 if (PyObject_IsTrue(result)) {
719 if (PyObject_IsTrue(result)) {
720 assert(!(self->lines[i].from_malloc));
720 assert(!(self->lines[i].from_malloc));
721 copy->lines[copy->numlines++] = self->lines[i];
721 copy->lines[copy->numlines++] = self->lines[i];
722 }
722 }
723 Py_DECREF(result);
723 Py_DECREF(result);
724 }
724 }
725 copy->livelines = copy->numlines;
725 copy->livelines = copy->numlines;
726 return copy;
726 return copy;
727 nomem:
727 nomem:
728 PyErr_NoMemory();
728 PyErr_NoMemory();
729 Py_XDECREF(copy);
729 Py_XDECREF(copy);
730 return NULL;
730 return NULL;
731 }
731 }
732
732
733 static PyObject *lazymanifest_diff(lazymanifest *self, PyObject *args)
733 static PyObject *lazymanifest_diff(lazymanifest *self, PyObject *args)
734 {
734 {
735 lazymanifest *other;
735 lazymanifest *other;
736 PyObject *pyclean = NULL;
736 PyObject *pyclean = NULL;
737 bool listclean;
737 bool listclean;
738 PyObject *emptyTup = NULL, *ret = NULL;
738 PyObject *emptyTup = NULL, *ret = NULL;
739 PyObject *es;
739 PyObject *es;
740 int sneedle = 0, oneedle = 0;
740 int sneedle = 0, oneedle = 0;
741 if (!PyArg_ParseTuple(args, "O!|O", &lazymanifestType, &other, &pyclean)) {
741 if (!PyArg_ParseTuple(args, "O!|O", &lazymanifestType, &other, &pyclean)) {
742 return NULL;
742 return NULL;
743 }
743 }
744 listclean = (!pyclean) ? false : PyObject_IsTrue(pyclean);
744 listclean = (!pyclean) ? false : PyObject_IsTrue(pyclean);
745 es = PyString_FromString("");
745 es = PyString_FromString("");
746 if (!es) {
746 if (!es) {
747 goto nomem;
747 goto nomem;
748 }
748 }
749 emptyTup = PyTuple_Pack(2, Py_None, es);
749 emptyTup = PyTuple_Pack(2, Py_None, es);
750 Py_DECREF(es);
750 Py_DECREF(es);
751 if (!emptyTup) {
751 if (!emptyTup) {
752 goto nomem;
752 goto nomem;
753 }
753 }
754 ret = PyDict_New();
754 ret = PyDict_New();
755 if (!ret) {
755 if (!ret) {
756 goto nomem;
756 goto nomem;
757 }
757 }
758 while (sneedle != self->numlines || oneedle != other->numlines) {
758 while (sneedle != self->numlines || oneedle != other->numlines) {
759 line *left = self->lines + sneedle;
759 line *left = self->lines + sneedle;
760 line *right = other->lines + oneedle;
760 line *right = other->lines + oneedle;
761 int result;
761 int result;
762 PyObject *key;
762 PyObject *key;
763 PyObject *outer;
763 PyObject *outer;
764 /* If we're looking at a deleted entry and it's not
764 /* If we're looking at a deleted entry and it's not
765 * the end of the manifest, just skip it. */
765 * the end of the manifest, just skip it. */
766 if (left->deleted && sneedle < self->numlines) {
766 if (left->deleted && sneedle < self->numlines) {
767 sneedle++;
767 sneedle++;
768 continue;
768 continue;
769 }
769 }
770 if (right->deleted && oneedle < other->numlines) {
770 if (right->deleted && oneedle < other->numlines) {
771 oneedle++;
771 oneedle++;
772 continue;
772 continue;
773 }
773 }
774 /* if we're at the end of either manifest, then we
774 /* if we're at the end of either manifest, then we
775 * know the remaining items are adds so we can skip
775 * know the remaining items are adds so we can skip
776 * the strcmp. */
776 * the strcmp. */
777 if (sneedle == self->numlines) {
777 if (sneedle == self->numlines) {
778 result = 1;
778 result = 1;
779 } else if (oneedle == other->numlines) {
779 } else if (oneedle == other->numlines) {
780 result = -1;
780 result = -1;
781 } else {
781 } else {
782 result = linecmp(left, right);
782 result = linecmp(left, right);
783 }
783 }
784 key = result <= 0 ?
784 key = result <= 0 ?
785 PyString_FromString(left->start) :
785 PyString_FromString(left->start) :
786 PyString_FromString(right->start);
786 PyString_FromString(right->start);
787 if (!key)
787 if (!key)
788 goto nomem;
788 goto nomem;
789 if (result < 0) {
789 if (result < 0) {
790 PyObject *l = hashflags(left);
790 PyObject *l = hashflags(left);
791 if (!l) {
791 if (!l) {
792 goto nomem;
792 goto nomem;
793 }
793 }
794 outer = PyTuple_Pack(2, l, emptyTup);
794 outer = PyTuple_Pack(2, l, emptyTup);
795 Py_DECREF(l);
795 Py_DECREF(l);
796 if (!outer) {
796 if (!outer) {
797 goto nomem;
797 goto nomem;
798 }
798 }
799 PyDict_SetItem(ret, key, outer);
799 PyDict_SetItem(ret, key, outer);
800 Py_DECREF(outer);
800 Py_DECREF(outer);
801 sneedle++;
801 sneedle++;
802 } else if (result > 0) {
802 } else if (result > 0) {
803 PyObject *r = hashflags(right);
803 PyObject *r = hashflags(right);
804 if (!r) {
804 if (!r) {
805 goto nomem;
805 goto nomem;
806 }
806 }
807 outer = PyTuple_Pack(2, emptyTup, r);
807 outer = PyTuple_Pack(2, emptyTup, r);
808 Py_DECREF(r);
808 Py_DECREF(r);
809 if (!outer) {
809 if (!outer) {
810 goto nomem;
810 goto nomem;
811 }
811 }
812 PyDict_SetItem(ret, key, outer);
812 PyDict_SetItem(ret, key, outer);
813 Py_DECREF(outer);
813 Py_DECREF(outer);
814 oneedle++;
814 oneedle++;
815 } else {
815 } else {
816 /* file exists in both manifests */
816 /* file exists in both manifests */
817 if (left->len != right->len
817 if (left->len != right->len
818 || memcmp(left->start, right->start, left->len)
818 || memcmp(left->start, right->start, left->len)
819 || left->hash_suffix != right->hash_suffix) {
819 || left->hash_suffix != right->hash_suffix) {
820 PyObject *l = hashflags(left);
820 PyObject *l = hashflags(left);
821 PyObject *r;
821 PyObject *r;
822 if (!l) {
822 if (!l) {
823 goto nomem;
823 goto nomem;
824 }
824 }
825 r = hashflags(right);
825 r = hashflags(right);
826 if (!r) {
826 if (!r) {
827 Py_DECREF(l);
827 Py_DECREF(l);
828 goto nomem;
828 goto nomem;
829 }
829 }
830 outer = PyTuple_Pack(2, l, r);
830 outer = PyTuple_Pack(2, l, r);
831 Py_DECREF(l);
831 Py_DECREF(l);
832 Py_DECREF(r);
832 Py_DECREF(r);
833 if (!outer) {
833 if (!outer) {
834 goto nomem;
834 goto nomem;
835 }
835 }
836 PyDict_SetItem(ret, key, outer);
836 PyDict_SetItem(ret, key, outer);
837 Py_DECREF(outer);
837 Py_DECREF(outer);
838 } else if (listclean) {
838 } else if (listclean) {
839 PyDict_SetItem(ret, key, Py_None);
839 PyDict_SetItem(ret, key, Py_None);
840 }
840 }
841 sneedle++;
841 sneedle++;
842 oneedle++;
842 oneedle++;
843 }
843 }
844 Py_DECREF(key);
844 Py_DECREF(key);
845 }
845 }
846 Py_DECREF(emptyTup);
846 Py_DECREF(emptyTup);
847 return ret;
847 return ret;
848 nomem:
848 nomem:
849 PyErr_NoMemory();
849 PyErr_NoMemory();
850 Py_XDECREF(ret);
850 Py_XDECREF(ret);
851 Py_XDECREF(emptyTup);
851 Py_XDECREF(emptyTup);
852 return NULL;
852 return NULL;
853 }
853 }
854
854
855 static PyMethodDef lazymanifest_methods[] = {
855 static PyMethodDef lazymanifest_methods[] = {
856 {"iterkeys", (PyCFunction)lazymanifest_getkeysiter, METH_NOARGS,
856 {"iterkeys", (PyCFunction)lazymanifest_getkeysiter, METH_NOARGS,
857 "Iterate over file names in this lazymanifest."},
857 "Iterate over file names in this lazymanifest."},
858 {"iterentries", (PyCFunction)lazymanifest_getentriesiter, METH_NOARGS,
858 {"iterentries", (PyCFunction)lazymanifest_getentriesiter, METH_NOARGS,
859 "Iterate over (path, nodeid, flags) typles in this lazymanifest."},
859 "Iterate over (path, nodeid, flags) typles in this lazymanifest."},
860 {"copy", (PyCFunction)lazymanifest_copy, METH_NOARGS,
860 {"copy", (PyCFunction)lazymanifest_copy, METH_NOARGS,
861 "Make a copy of this lazymanifest."},
861 "Make a copy of this lazymanifest."},
862 {"filtercopy", (PyCFunction)lazymanifest_filtercopy, METH_O,
862 {"filtercopy", (PyCFunction)lazymanifest_filtercopy, METH_O,
863 "Make a copy of this manifest filtered by matchfn."},
863 "Make a copy of this manifest filtered by matchfn."},
864 {"diff", (PyCFunction)lazymanifest_diff, METH_VARARGS,
864 {"diff", (PyCFunction)lazymanifest_diff, METH_VARARGS,
865 "Compare this lazymanifest to another one."},
865 "Compare this lazymanifest to another one."},
866 {"text", (PyCFunction)lazymanifest_text, METH_NOARGS,
866 {"text", (PyCFunction)lazymanifest_text, METH_NOARGS,
867 "Encode this manifest to text."},
867 "Encode this manifest to text."},
868 {NULL},
868 {NULL},
869 };
869 };
870
870
871 static PyTypeObject lazymanifestType = {
871 static PyTypeObject lazymanifestType = {
872 PyObject_HEAD_INIT(NULL)
872 PyObject_HEAD_INIT(NULL)
873 0, /* ob_size */
873 0, /* ob_size */
874 "parsers.lazymanifest", /* tp_name */
874 "parsers.lazymanifest", /* tp_name */
875 sizeof(lazymanifest), /* tp_basicsize */
875 sizeof(lazymanifest), /* tp_basicsize */
876 0, /* tp_itemsize */
876 0, /* tp_itemsize */
877 (destructor)lazymanifest_dealloc, /* tp_dealloc */
877 (destructor)lazymanifest_dealloc, /* tp_dealloc */
878 0, /* tp_print */
878 0, /* tp_print */
879 0, /* tp_getattr */
879 0, /* tp_getattr */
880 0, /* tp_setattr */
880 0, /* tp_setattr */
881 0, /* tp_compare */
881 0, /* tp_compare */
882 0, /* tp_repr */
882 0, /* tp_repr */
883 0, /* tp_as_number */
883 0, /* tp_as_number */
884 &lazymanifest_seq_meths, /* tp_as_sequence */
884 &lazymanifest_seq_meths, /* tp_as_sequence */
885 &lazymanifest_mapping_methods, /* tp_as_mapping */
885 &lazymanifest_mapping_methods, /* tp_as_mapping */
886 0, /* tp_hash */
886 0, /* tp_hash */
887 0, /* tp_call */
887 0, /* tp_call */
888 0, /* tp_str */
888 0, /* tp_str */
889 0, /* tp_getattro */
889 0, /* tp_getattro */
890 0, /* tp_setattro */
890 0, /* tp_setattro */
891 0, /* tp_as_buffer */
891 0, /* tp_as_buffer */
892 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_SEQUENCE_IN, /* tp_flags */
892 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_SEQUENCE_IN, /* tp_flags */
893 "TODO(augie)", /* tp_doc */
893 "TODO(augie)", /* tp_doc */
894 0, /* tp_traverse */
894 0, /* tp_traverse */
895 0, /* tp_clear */
895 0, /* tp_clear */
896 0, /* tp_richcompare */
896 0, /* tp_richcompare */
897 0, /* tp_weaklistoffset */
897 0, /* tp_weaklistoffset */
898 (getiterfunc)lazymanifest_getkeysiter, /* tp_iter */
898 (getiterfunc)lazymanifest_getkeysiter, /* tp_iter */
899 0, /* tp_iternext */
899 0, /* tp_iternext */
900 lazymanifest_methods, /* tp_methods */
900 lazymanifest_methods, /* tp_methods */
901 0, /* tp_members */
901 0, /* tp_members */
902 0, /* tp_getset */
902 0, /* tp_getset */
903 0, /* tp_base */
903 0, /* tp_base */
904 0, /* tp_dict */
904 0, /* tp_dict */
905 0, /* tp_descr_get */
905 0, /* tp_descr_get */
906 0, /* tp_descr_set */
906 0, /* tp_descr_set */
907 0, /* tp_dictoffset */
907 0, /* tp_dictoffset */
908 (initproc)lazymanifest_init, /* tp_init */
908 (initproc)lazymanifest_init, /* tp_init */
909 0, /* tp_alloc */
909 0, /* tp_alloc */
910 };
910 };
911
911
912 void manifest_module_init(PyObject * mod)
912 void manifest_module_init(PyObject * mod)
913 {
913 {
914 lazymanifestType.tp_new = PyType_GenericNew;
914 lazymanifestType.tp_new = PyType_GenericNew;
915 if (PyType_Ready(&lazymanifestType) < 0)
915 if (PyType_Ready(&lazymanifestType) < 0)
916 return;
916 return;
917 Py_INCREF(&lazymanifestType);
917 Py_INCREF(&lazymanifestType);
918
918
919 PyModule_AddObject(mod, "lazymanifest",
919 PyModule_AddObject(mod, "lazymanifest",
920 (PyObject *)&lazymanifestType);
920 (PyObject *)&lazymanifestType);
921 }
921 }
General Comments 0
You need to be logged in to leave comments. Login now