Mercurial > hg
annotate mercurial/cext/revlog.c @ 39016:39b8277e2115
changegroup: differentiate between fulltext and diff based deltas
Previously, revisiondelta encoded a delta and an optional prefix
containing a delta header. The underlying code could populate
the delta with either a real delta or a fulltext revision.
Following the theme of wanting to defer serialization of revision
data to the changegroup format as long as possible, it seems
prudent for the revision delta instance to capture what type of
data is being represented. This could possibly allow us to
encode revision data differently in the future. But for the
short term, it makes the behavior of a revisiondelta more
explicit.
Differential Revision: https://phab.mercurial-scm.org/D4213
author | Gregory Szorc <gregory.szorc@gmail.com> |
---|---|
date | Wed, 08 Aug 2018 16:01:26 -0700 |
parents | c1de67691d5b |
children | 52e9bf215f96 |
rev | line source |
---|---|
6389
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
1 /* |
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
2 parsers.c - efficient content parsing |
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
3 |
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
4 Copyright 2008 Matt Mackall <mpm@selenic.com> and others |
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
5 |
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
6 This software may be used and distributed according to the terms of |
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
7 the GNU General Public License, incorporated herein by reference. |
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
8 */ |
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
9 |
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
10 #include <Python.h> |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
11 #include <assert.h> |
6389
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
12 #include <ctype.h> |
17356
511dfb34b412
parsers: fix an integer size warning issued by clang
Bryan O'Sullivan <bryano@fb.com>
parents:
17353
diff
changeset
|
13 #include <stddef.h> |
6389
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
14 #include <string.h> |
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
15 |
34438
b90e8da190da
cext: reorder #include
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34437
diff
changeset
|
16 #include "bitmanipulation.h" |
33758
0f4ac3b6dee4
cext: factor out header for charencode.c
Yuya Nishihara <yuya@tcha.org>
parents:
33475
diff
changeset
|
17 #include "charencode.h" |
11361
3de3d670d2b6
parsers.c: Added support for py3k.
Renato Cunha <renatoc@gmail.com>
parents:
10449
diff
changeset
|
18 #include "util.h" |
3de3d670d2b6
parsers.c: Added support for py3k.
Renato Cunha <renatoc@gmail.com>
parents:
10449
diff
changeset
|
19 |
30112
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
20 #ifdef IS_PY3K |
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
21 /* The mapping of Python types is meant to be temporary to get Python |
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
22 * 3 to compile. We should remove this once Python 3 support is fully |
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
23 * supported and proper types are used in the extensions themselves. */ |
30169
5f7151e6de85
parsers: alias more PyInt* symbols on Python 3
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30112
diff
changeset
|
24 #define PyInt_Check PyLong_Check |
30112
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
25 #define PyInt_FromLong PyLong_FromLong |
30169
5f7151e6de85
parsers: alias more PyInt* symbols on Python 3
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30112
diff
changeset
|
26 #define PyInt_FromSsize_t PyLong_FromSsize_t |
5f7151e6de85
parsers: alias more PyInt* symbols on Python 3
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30112
diff
changeset
|
27 #define PyInt_AS_LONG PyLong_AS_LONG |
30112
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
28 #define PyInt_AsLong PyLong_AsLong |
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
29 #endif |
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
30 |
38939
53bc73fae1a3
index: add pointer from nodetree back to index
Martin von Zweigbergk <martinvonz@google.com>
parents:
38938
diff
changeset
|
31 typedef struct indexObjectStruct indexObject; |
53bc73fae1a3
index: add pointer from nodetree back to index
Martin von Zweigbergk <martinvonz@google.com>
parents:
38938
diff
changeset
|
32 |
38912
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
33 typedef struct { |
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
34 int children[16]; |
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
35 } nodetreenode; |
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
36 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
37 /* |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
38 * A base-16 trie for fast node->rev mapping. |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
39 * |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
40 * Positive value is index of the next node in the trie |
38846
f738c502e43b
index: store nullrev as -1 in nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38845
diff
changeset
|
41 * Negative value is a leaf: -(rev + 2) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
42 * Zero is empty |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
43 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
44 typedef struct { |
38939
53bc73fae1a3
index: add pointer from nodetree back to index
Martin von Zweigbergk <martinvonz@google.com>
parents:
38938
diff
changeset
|
45 indexObject *index; |
38912
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
46 nodetreenode *nodes; |
38914
f28e64bbdd29
index: drop now-redundant "nt" prefix of fields in nodetree struct
Martin von Zweigbergk <martinvonz@google.com>
parents:
38913
diff
changeset
|
47 unsigned length; /* # nodes in use */ |
f28e64bbdd29
index: drop now-redundant "nt" prefix of fields in nodetree struct
Martin von Zweigbergk <martinvonz@google.com>
parents:
38913
diff
changeset
|
48 unsigned capacity; /* # nodes allocated */ |
f28e64bbdd29
index: drop now-redundant "nt" prefix of fields in nodetree struct
Martin von Zweigbergk <martinvonz@google.com>
parents:
38913
diff
changeset
|
49 int depth; /* maximum depth of tree */ |
f28e64bbdd29
index: drop now-redundant "nt" prefix of fields in nodetree struct
Martin von Zweigbergk <martinvonz@google.com>
parents:
38913
diff
changeset
|
50 int splits; /* # splits performed */ |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
51 } nodetree; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
52 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
53 /* |
26098 | 54 * This class has two behaviors. |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
55 * |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
56 * When used in a list-like way (with integer keys), we decode an |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
57 * entry in a RevlogNG index file on demand. Our last entry is a |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
58 * sentinel, always a nullid. We have limited support for |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
59 * integer-keyed insert and delete, only at elements right before the |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
60 * sentinel. |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
61 * |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
62 * With string keys, we lazily perform a reverse mapping from node to |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
63 * rev, using a base-16 trie. |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
64 */ |
38939
53bc73fae1a3
index: add pointer from nodetree back to index
Martin von Zweigbergk <martinvonz@google.com>
parents:
38938
diff
changeset
|
65 struct indexObjectStruct { |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
66 PyObject_HEAD |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
67 /* Type-specific fields go here. */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
68 PyObject *data; /* raw bytes of index */ |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
69 Py_buffer buf; /* buffer of data */ |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
70 PyObject **cache; /* cached tuples */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
71 const char **offsets; /* populated on demand */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
72 Py_ssize_t raw_length; /* original number of elements */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
73 Py_ssize_t length; /* current number of elements */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
74 PyObject *added; /* populated on demand */ |
16787
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
75 PyObject *headrevs; /* cache, invalidated on changes */ |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
76 PyObject *filteredrevs;/* filtered revs set */ |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
77 nodetree *nt; /* base-16 trie */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
78 int ntrev; /* last rev scanned */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
79 int ntlookups; /* # lookups */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
80 int ntmisses; /* # lookups that miss the cache */ |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
81 int inlined; |
38939
53bc73fae1a3
index: add pointer from nodetree back to index
Martin von Zweigbergk <martinvonz@google.com>
parents:
38938
diff
changeset
|
82 }; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
83 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
84 static Py_ssize_t index_length(const indexObject *self) |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
85 { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
86 if (self->added == NULL) |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
87 return self->length - 1; |
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
88 return self->length + PyList_GET_SIZE(self->added) - 1; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
89 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
90 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
91 static PyObject *nullentry; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
92 static const char nullid[20]; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
93 |
22401
9ba8a93e55f5
parsers: ensure correct return type for inline_scan
Henrik Stuart <hg@hstuart.dk>
parents:
22400
diff
changeset
|
94 static Py_ssize_t inline_scan(indexObject *self, const char **offsets); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
95 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
96 #if LONG_MAX == 0x7fffffffL |
36621
4015b9248da0
cext: mark tuple_format as a constant
Yuya Nishihara <yuya@tcha.org>
parents:
36620
diff
changeset
|
97 static const char *const tuple_format = PY23("Kiiiiiis#", "Kiiiiiiy#"); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
98 #else |
36621
4015b9248da0
cext: mark tuple_format as a constant
Yuya Nishihara <yuya@tcha.org>
parents:
36620
diff
changeset
|
99 static const char *const tuple_format = PY23("kiiiiiis#", "kiiiiiiy#"); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
100 #endif |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
101 |
16863
bbedef66c6f3
parsers: replace magic number 64 with symbolic constant
Bryan O'Sullivan <bryano@fb.com>
parents:
16787
diff
changeset
|
102 /* A RevlogNG v1 index entry is 64 bytes long. */ |
bbedef66c6f3
parsers: replace magic number 64 with symbolic constant
Bryan O'Sullivan <bryano@fb.com>
parents:
16787
diff
changeset
|
103 static const long v1_hdrsize = 64; |
bbedef66c6f3
parsers: replace magic number 64 with symbolic constant
Bryan O'Sullivan <bryano@fb.com>
parents:
16787
diff
changeset
|
104 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
105 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
106 * Return a pointer to the beginning of a RevlogNG record. |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
107 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
108 static const char *index_deref(indexObject *self, Py_ssize_t pos) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
109 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
110 if (self->inlined && pos > 0) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
111 if (self->offsets == NULL) { |
31470
bc445c556d3c
parsers: use Python memory allocator for indexObject->offsets
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31469
diff
changeset
|
112 self->offsets = PyMem_Malloc(self->raw_length * |
bc445c556d3c
parsers: use Python memory allocator for indexObject->offsets
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31469
diff
changeset
|
113 sizeof(*self->offsets)); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
114 if (self->offsets == NULL) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
115 return (const char *)PyErr_NoMemory(); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
116 inline_scan(self, self->offsets); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
117 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
118 return self->offsets[pos]; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
119 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
120 |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
121 return (const char *)(self->buf.buf) + pos * v1_hdrsize; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
122 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
123 |
25810
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
124 static inline int index_get_parents(indexObject *self, Py_ssize_t rev, |
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
125 int *ps, int maxrev) |
25311
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
126 { |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
127 if (rev >= self->length - 1) { |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
128 PyObject *tuple = PyList_GET_ITEM(self->added, |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
129 rev - self->length + 1); |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
130 ps[0] = (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 5)); |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
131 ps[1] = (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 6)); |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
132 } else { |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
133 const char *data = index_deref(self, rev); |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
134 ps[0] = getbe32(data + 24); |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
135 ps[1] = getbe32(data + 28); |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
136 } |
25810
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
137 /* If index file is corrupted, ps[] may point to invalid revisions. So |
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
138 * there is a risk of buffer overflow to trust them unconditionally. */ |
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
139 if (ps[0] > maxrev || ps[1] > maxrev) { |
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
140 PyErr_SetString(PyExc_ValueError, "parent out of range"); |
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
141 return -1; |
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
142 } |
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
143 return 0; |
25311
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
144 } |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
145 |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
146 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
147 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
148 * RevlogNG format (all in big endian, data may be inlined): |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
149 * 6 bytes: offset |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
150 * 2 bytes: flags |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
151 * 4 bytes: compressed length |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
152 * 4 bytes: uncompressed length |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
153 * 4 bytes: base revision |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
154 * 4 bytes: link revision |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
155 * 4 bytes: parent 1 revision |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
156 * 4 bytes: parent 2 revision |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
157 * 32 bytes: nodeid (only 20 bytes used) |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
158 */ |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
159 static PyObject *index_get(indexObject *self, Py_ssize_t pos) |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
160 { |
7154
7fdf7a0a41b7
index parser: fix refcounting in case of errors, refactor
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7135
diff
changeset
|
161 uint64_t offset_flags; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
162 int comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2; |
7154
7fdf7a0a41b7
index parser: fix refcounting in case of errors, refactor
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7135
diff
changeset
|
163 const char *c_node_id; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
164 const char *data; |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
165 Py_ssize_t length = index_length(self); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
166 PyObject *entry; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
167 |
38852
a3dacabd476b
index: don't allow index[len(index)] to mean nullid
Martin von Zweigbergk <martinvonz@google.com>
parents:
38851
diff
changeset
|
168 if (pos == -1) { |
38847
f3d394ea17db
index: handle index[-1] as nullid more explicitly
Martin von Zweigbergk <martinvonz@google.com>
parents:
38846
diff
changeset
|
169 Py_INCREF(nullentry); |
f3d394ea17db
index: handle index[-1] as nullid more explicitly
Martin von Zweigbergk <martinvonz@google.com>
parents:
38846
diff
changeset
|
170 return nullentry; |
f3d394ea17db
index: handle index[-1] as nullid more explicitly
Martin von Zweigbergk <martinvonz@google.com>
parents:
38846
diff
changeset
|
171 } |
f3d394ea17db
index: handle index[-1] as nullid more explicitly
Martin von Zweigbergk <martinvonz@google.com>
parents:
38846
diff
changeset
|
172 |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
173 if (pos < 0 || pos >= length) { |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
174 PyErr_SetString(PyExc_IndexError, "revlog index out of range"); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
175 return NULL; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
176 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
177 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
178 if (pos >= self->length - 1) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
179 PyObject *obj; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
180 obj = PyList_GET_ITEM(self->added, pos - self->length + 1); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
181 Py_INCREF(obj); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
182 return obj; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
183 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
184 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
185 if (self->cache) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
186 if (self->cache[pos]) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
187 Py_INCREF(self->cache[pos]); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
188 return self->cache[pos]; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
189 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
190 } else { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
191 self->cache = calloc(self->raw_length, sizeof(PyObject *)); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
192 if (self->cache == NULL) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
193 return PyErr_NoMemory(); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
194 } |
7190
aecea6934fdd
Some additional space/tab cleanups
Thomas Arendsen Hein <thomas@intevation.de>
parents:
7186
diff
changeset
|
195 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
196 data = index_deref(self, pos); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
197 if (data == NULL) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
198 return NULL; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
199 |
16437
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
200 offset_flags = getbe32(data + 4); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
201 if (pos == 0) /* mask out version number for the first entry */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
202 offset_flags &= 0xFFFF; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
203 else { |
16437
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
204 uint32_t offset_high = getbe32(data); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
205 offset_flags |= ((uint64_t)offset_high) << 32; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
206 } |
7154
7fdf7a0a41b7
index parser: fix refcounting in case of errors, refactor
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7135
diff
changeset
|
207 |
16437
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
208 comp_len = getbe32(data + 8); |
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
209 uncomp_len = getbe32(data + 12); |
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
210 base_rev = getbe32(data + 16); |
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
211 link_rev = getbe32(data + 20); |
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
212 parent_1 = getbe32(data + 24); |
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
213 parent_2 = getbe32(data + 28); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
214 c_node_id = data + 32; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
215 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
216 entry = Py_BuildValue(tuple_format, offset_flags, comp_len, |
13254
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
11361
diff
changeset
|
217 uncomp_len, base_rev, link_rev, |
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
11361
diff
changeset
|
218 parent_1, parent_2, c_node_id, 20); |
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
11361
diff
changeset
|
219 |
19726
b3c8c6f2b5c1
parsers: use Py_INCREF safely
Bryan O'Sullivan <bryano@fb.com>
parents:
19725
diff
changeset
|
220 if (entry) { |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
221 PyObject_GC_UnTrack(entry); |
19726
b3c8c6f2b5c1
parsers: use Py_INCREF safely
Bryan O'Sullivan <bryano@fb.com>
parents:
19725
diff
changeset
|
222 Py_INCREF(entry); |
b3c8c6f2b5c1
parsers: use Py_INCREF safely
Bryan O'Sullivan <bryano@fb.com>
parents:
19725
diff
changeset
|
223 } |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
224 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
225 self->cache[pos] = entry; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
226 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
227 return entry; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
228 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
229 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
230 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
231 * Return the 20-byte SHA of the node corresponding to the given rev. |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
232 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
233 static const char *index_node(indexObject *self, Py_ssize_t pos) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
234 { |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
235 Py_ssize_t length = index_length(self); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
236 const char *data; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
237 |
38867
4c0fd3f0a15d
index: drop support for nullid at position len(index) in index_node
Martin von Zweigbergk <martinvonz@google.com>
parents:
38866
diff
changeset
|
238 if (pos == -1) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
239 return nullid; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
240 |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
241 if (pos >= length) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
242 return NULL; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
243 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
244 if (pos >= self->length - 1) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
245 PyObject *tuple, *str; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
246 tuple = PyList_GET_ITEM(self->added, pos - self->length + 1); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
247 str = PyTuple_GetItem(tuple, 7); |
30100
c5afe5531709
parsers: convert PyString* to PyBytes*
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30090
diff
changeset
|
248 return str ? PyBytes_AS_STRING(str) : NULL; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
249 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
250 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
251 data = index_deref(self, pos); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
252 return data ? data + 32 : NULL; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
253 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
254 |
37860
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
255 /* |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
256 * Return the 20-byte SHA of the node corresponding to the given rev. The |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
257 * rev is assumed to be existing. If not, an exception is set. |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
258 */ |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
259 static const char *index_node_existing(indexObject *self, Py_ssize_t pos) |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
260 { |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
261 const char *node = index_node(self, pos); |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
262 if (node == NULL) { |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
263 PyErr_Format(PyExc_IndexError, "could not access rev %d", |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
264 (int)pos); |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
265 } |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
266 return node; |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
267 } |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
268 |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
269 static int nt_insert(nodetree *self, const char *node, int rev); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
270 |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
271 static int node_check(PyObject *obj, char **node) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
272 { |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
273 Py_ssize_t nodelen; |
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
274 if (PyBytes_AsStringAndSize(obj, node, &nodelen) == -1) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
275 return -1; |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
276 if (nodelen == 20) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
277 return 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
278 PyErr_SetString(PyExc_ValueError, "20-byte hash required"); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
279 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
280 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
281 |
38850
6104b203bec8
index: replace insert(-1, e) method by append(e) method
Martin von Zweigbergk <martinvonz@google.com>
parents:
38848
diff
changeset
|
282 static PyObject *index_append(indexObject *self, PyObject *obj) |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
283 { |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
284 char *node; |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
285 Py_ssize_t len; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
286 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
287 if (!PyTuple_Check(obj) || PyTuple_GET_SIZE(obj) != 8) { |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
288 PyErr_SetString(PyExc_TypeError, "8-tuple required"); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
289 return NULL; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
290 } |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
291 |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
292 if (node_check(PyTuple_GET_ITEM(obj, 7), &node) == -1) |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
293 return NULL; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
294 |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
295 len = index_length(self); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
296 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
297 if (self->added == NULL) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
298 self->added = PyList_New(0); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
299 if (self->added == NULL) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
300 return NULL; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
301 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
302 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
303 if (PyList_Append(self->added, obj) == -1) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
304 return NULL; |
13254
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
11361
diff
changeset
|
305 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
306 if (self->nt) |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
307 nt_insert(self->nt, node, len); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
308 |
16787
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
309 Py_CLEAR(self->headrevs); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
310 Py_RETURN_NONE; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
311 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
312 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
313 static PyObject *index_stats(indexObject *self) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
314 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
315 PyObject *obj = PyDict_New(); |
23948
bd307b462ce2
parsers: avoid leaking several PyObjects in index_stats
Augie Fackler <augie@google.com>
parents:
23947
diff
changeset
|
316 PyObject *t = NULL; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
317 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
318 if (obj == NULL) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
319 return NULL; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
320 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
321 #define istat(__n, __d) \ |
28792
507136150d2b
parsers: fix istat macro to work with single line if statement
Matt Fowles <matt.fowles@gmail.com>
parents:
28386
diff
changeset
|
322 do { \ |
507136150d2b
parsers: fix istat macro to work with single line if statement
Matt Fowles <matt.fowles@gmail.com>
parents:
28386
diff
changeset
|
323 t = PyInt_FromSsize_t(self->__n); \ |
507136150d2b
parsers: fix istat macro to work with single line if statement
Matt Fowles <matt.fowles@gmail.com>
parents:
28386
diff
changeset
|
324 if (!t) \ |
507136150d2b
parsers: fix istat macro to work with single line if statement
Matt Fowles <matt.fowles@gmail.com>
parents:
28386
diff
changeset
|
325 goto bail; \ |
507136150d2b
parsers: fix istat macro to work with single line if statement
Matt Fowles <matt.fowles@gmail.com>
parents:
28386
diff
changeset
|
326 if (PyDict_SetItemString(obj, __d, t) == -1) \ |
507136150d2b
parsers: fix istat macro to work with single line if statement
Matt Fowles <matt.fowles@gmail.com>
parents:
28386
diff
changeset
|
327 goto bail; \ |
507136150d2b
parsers: fix istat macro to work with single line if statement
Matt Fowles <matt.fowles@gmail.com>
parents:
28386
diff
changeset
|
328 Py_DECREF(t); \ |
507136150d2b
parsers: fix istat macro to work with single line if statement
Matt Fowles <matt.fowles@gmail.com>
parents:
28386
diff
changeset
|
329 } while (0) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
330 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
331 if (self->added) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
332 Py_ssize_t len = PyList_GET_SIZE(self->added); |
23948
bd307b462ce2
parsers: avoid leaking several PyObjects in index_stats
Augie Fackler <augie@google.com>
parents:
23947
diff
changeset
|
333 t = PyInt_FromSsize_t(len); |
bd307b462ce2
parsers: avoid leaking several PyObjects in index_stats
Augie Fackler <augie@google.com>
parents:
23947
diff
changeset
|
334 if (!t) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
335 goto bail; |
23948
bd307b462ce2
parsers: avoid leaking several PyObjects in index_stats
Augie Fackler <augie@google.com>
parents:
23947
diff
changeset
|
336 if (PyDict_SetItemString(obj, "index entries added", t) == -1) |
bd307b462ce2
parsers: avoid leaking several PyObjects in index_stats
Augie Fackler <augie@google.com>
parents:
23947
diff
changeset
|
337 goto bail; |
bd307b462ce2
parsers: avoid leaking several PyObjects in index_stats
Augie Fackler <augie@google.com>
parents:
23947
diff
changeset
|
338 Py_DECREF(t); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
339 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
340 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
341 if (self->raw_length != self->length - 1) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
342 istat(raw_length, "revs on disk"); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
343 istat(length, "revs in memory"); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
344 istat(ntlookups, "node trie lookups"); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
345 istat(ntmisses, "node trie misses"); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
346 istat(ntrev, "node trie last rev scanned"); |
38913
c2c253558e3c
index: move more fields onto nodetree type
Martin von Zweigbergk <martinvonz@google.com>
parents:
38912
diff
changeset
|
347 if (self->nt) { |
38914
f28e64bbdd29
index: drop now-redundant "nt" prefix of fields in nodetree struct
Martin von Zweigbergk <martinvonz@google.com>
parents:
38913
diff
changeset
|
348 istat(nt->capacity, "node trie capacity"); |
f28e64bbdd29
index: drop now-redundant "nt" prefix of fields in nodetree struct
Martin von Zweigbergk <martinvonz@google.com>
parents:
38913
diff
changeset
|
349 istat(nt->depth, "node trie depth"); |
f28e64bbdd29
index: drop now-redundant "nt" prefix of fields in nodetree struct
Martin von Zweigbergk <martinvonz@google.com>
parents:
38913
diff
changeset
|
350 istat(nt->length, "node trie count"); |
f28e64bbdd29
index: drop now-redundant "nt" prefix of fields in nodetree struct
Martin von Zweigbergk <martinvonz@google.com>
parents:
38913
diff
changeset
|
351 istat(nt->splits, "node trie splits"); |
38913
c2c253558e3c
index: move more fields onto nodetree type
Martin von Zweigbergk <martinvonz@google.com>
parents:
38912
diff
changeset
|
352 } |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
353 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
354 #undef istat |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
355 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
356 return obj; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
357 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
358 bail: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
359 Py_XDECREF(obj); |
23948
bd307b462ce2
parsers: avoid leaking several PyObjects in index_stats
Augie Fackler <augie@google.com>
parents:
23947
diff
changeset
|
360 Py_XDECREF(t); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
361 return NULL; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
362 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
363 |
16787
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
364 /* |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
365 * When we cache a list, we want to be sure the caller can't mutate |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
366 * the cached copy. |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
367 */ |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
368 static PyObject *list_copy(PyObject *list) |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
369 { |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
370 Py_ssize_t len = PyList_GET_SIZE(list); |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
371 PyObject *newlist = PyList_New(len); |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
372 Py_ssize_t i; |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
373 |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
374 if (newlist == NULL) |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
375 return NULL; |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
376 |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
377 for (i = 0; i < len; i++) { |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
378 PyObject *obj = PyList_GET_ITEM(list, i); |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
379 Py_INCREF(obj); |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
380 PyList_SET_ITEM(newlist, i, obj); |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
381 } |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
382 |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
383 return newlist; |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
384 } |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
385 |
34440
7ed0750c71a1
cext: wrap before brace for functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34438
diff
changeset
|
386 static int check_filter(PyObject *filter, Py_ssize_t arg) |
7ed0750c71a1
cext: wrap before brace for functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34438
diff
changeset
|
387 { |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
388 if (filter) { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
389 PyObject *arglist, *result; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
390 int isfiltered; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
391 |
26107
50582df9d7a7
parsers: fix two cases of unsigned long instead of Py_ssize_t
Augie Fackler <augie@google.com>
parents:
26098
diff
changeset
|
392 arglist = Py_BuildValue("(n)", arg); |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
393 if (!arglist) { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
394 return -1; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
395 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
396 |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
397 result = PyEval_CallObject(filter, arglist); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
398 Py_DECREF(arglist); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
399 if (!result) { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
400 return -1; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
401 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
402 |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
403 /* PyObject_IsTrue returns 1 if true, 0 if false, -1 if error, |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
404 * same as this function, so we can just return it directly.*/ |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
405 isfiltered = PyObject_IsTrue(result); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
406 Py_DECREF(result); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
407 return isfiltered; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
408 } else { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
409 return 0; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
410 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
411 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
412 |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
413 static Py_ssize_t add_roots_get_min(indexObject *self, PyObject *list, |
24499
90db70de6f9c
parsers.c: avoid implicit conversion loses integer warnings
André Sintzoff <andre.sintzoff@gmail.com>
parents:
24443
diff
changeset
|
414 Py_ssize_t marker, char *phases) |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
415 { |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
416 PyObject *iter = NULL; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
417 PyObject *iter_item = NULL; |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
418 Py_ssize_t min_idx = index_length(self) + 2; |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
419 long iter_item_long; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
420 |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
421 if (PyList_GET_SIZE(list) != 0) { |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
422 iter = PyObject_GetIter(list); |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
423 if (iter == NULL) |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
424 return -2; |
34437
ce26a13869fb
cext: move braces for control statements to same line
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33758
diff
changeset
|
425 while ((iter_item = PyIter_Next(iter))) { |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
426 iter_item_long = PyInt_AS_LONG(iter_item); |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
427 Py_DECREF(iter_item); |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
428 if (iter_item_long < min_idx) |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
429 min_idx = iter_item_long; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
430 phases[iter_item_long] = marker; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
431 } |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
432 Py_DECREF(iter); |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
433 } |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
434 |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
435 return min_idx; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
436 } |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
437 |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
438 static inline void set_phase_from_parents(char *phases, int parent_1, |
24499
90db70de6f9c
parsers.c: avoid implicit conversion loses integer warnings
André Sintzoff <andre.sintzoff@gmail.com>
parents:
24443
diff
changeset
|
439 int parent_2, Py_ssize_t i) |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
440 { |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
441 if (parent_1 >= 0 && phases[parent_1] > phases[i]) |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
442 phases[i] = phases[parent_1]; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
443 if (parent_2 >= 0 && phases[parent_2] > phases[i]) |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
444 phases[i] = phases[parent_2]; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
445 } |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
446 |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
447 static PyObject *reachableroots2(indexObject *self, PyObject *args) |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
448 { |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
449 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
450 /* Input */ |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
451 long minroot; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
452 PyObject *includepatharg = NULL; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
453 int includepath = 0; |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
454 /* heads and roots are lists */ |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
455 PyObject *heads = NULL; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
456 PyObject *roots = NULL; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
457 PyObject *reachable = NULL; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
458 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
459 PyObject *val; |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
460 Py_ssize_t len = index_length(self); |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
461 long revnum; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
462 Py_ssize_t k; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
463 Py_ssize_t i; |
26042
2a3010ba6f52
reachableroots: give anonymous name to short-lived "numheads" variable
Yuya Nishihara <yuya@tcha.org>
parents:
26041
diff
changeset
|
464 Py_ssize_t l; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
465 int r; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
466 int parents[2]; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
467 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
468 /* Internal data structure: |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
469 * tovisit: array of length len+1 (all revs + nullrev), filled upto lentovisit |
26044
b3ad349d0e50
reachableroots: extend "revstates" to array of bit flags
Yuya Nishihara <yuya@tcha.org>
parents:
26043
diff
changeset
|
470 * revstates: array of length len+1 (all revs + nullrev) */ |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
471 int *tovisit = NULL; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
472 long lentovisit = 0; |
26054
5049e10fed14
reachableroots: use internal "revstates" array to test if rev is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26053
diff
changeset
|
473 enum { RS_SEEN = 1, RS_ROOT = 2, RS_REACHABLE = 4 }; |
26043
f2f0a3ab6e41
reachableroots: rename "seen" array to "revstates" for future extension
Yuya Nishihara <yuya@tcha.org>
parents:
26042
diff
changeset
|
474 char *revstates = NULL; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
475 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
476 /* Get arguments */ |
26009
bbb698697efc
reachableroots: fix transposition of set and list types in PyArg_ParseTuple
Augie Fackler <augie@google.com>
parents:
26008
diff
changeset
|
477 if (!PyArg_ParseTuple(args, "lO!O!O!", &minroot, &PyList_Type, &heads, |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
478 &PyList_Type, &roots, |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
479 &PyBool_Type, &includepatharg)) |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
480 goto bail; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
481 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
482 if (includepatharg == Py_True) |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
483 includepath = 1; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
484 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
485 /* Initialize return set */ |
26055
607868eccaa7
reachableroots: return list of revisions instead of set
Yuya Nishihara <yuya@tcha.org>
parents:
26054
diff
changeset
|
486 reachable = PyList_New(0); |
607868eccaa7
reachableroots: return list of revisions instead of set
Yuya Nishihara <yuya@tcha.org>
parents:
26054
diff
changeset
|
487 if (reachable == NULL) |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
488 goto bail; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
489 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
490 /* Initialize internal datastructures */ |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
491 tovisit = (int *)malloc((len + 1) * sizeof(int)); |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
492 if (tovisit == NULL) { |
26008
59d57ea69ae6
reachableroots: consistently use short-form of PyErr_NoMemory()
Augie Fackler <augie@google.com>
parents:
26007
diff
changeset
|
493 PyErr_NoMemory(); |
26016
c8d41c9c23c7
reachableroots: unify bail cases to raise exception correctly
Yuya Nishihara <yuya@tcha.org>
parents:
26015
diff
changeset
|
494 goto bail; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
495 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
496 |
26043
f2f0a3ab6e41
reachableroots: rename "seen" array to "revstates" for future extension
Yuya Nishihara <yuya@tcha.org>
parents:
26042
diff
changeset
|
497 revstates = (char *)calloc(len + 1, 1); |
f2f0a3ab6e41
reachableroots: rename "seen" array to "revstates" for future extension
Yuya Nishihara <yuya@tcha.org>
parents:
26042
diff
changeset
|
498 if (revstates == NULL) { |
26008
59d57ea69ae6
reachableroots: consistently use short-form of PyErr_NoMemory()
Augie Fackler <augie@google.com>
parents:
26007
diff
changeset
|
499 PyErr_NoMemory(); |
26016
c8d41c9c23c7
reachableroots: unify bail cases to raise exception correctly
Yuya Nishihara <yuya@tcha.org>
parents:
26015
diff
changeset
|
500 goto bail; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
501 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
502 |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
503 l = PyList_GET_SIZE(roots); |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
504 for (i = 0; i < l; i++) { |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
505 revnum = PyInt_AsLong(PyList_GET_ITEM(roots, i)); |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
506 if (revnum == -1 && PyErr_Occurred()) |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
507 goto bail; |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
508 /* If root is out of range, e.g. wdir(), it must be unreachable |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
509 * from heads. So we can just ignore it. */ |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
510 if (revnum + 1 < 0 || revnum + 1 >= len + 1) |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
511 continue; |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
512 revstates[revnum + 1] |= RS_ROOT; |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
513 } |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
514 |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
515 /* Populate tovisit with all the heads */ |
26042
2a3010ba6f52
reachableroots: give anonymous name to short-lived "numheads" variable
Yuya Nishihara <yuya@tcha.org>
parents:
26041
diff
changeset
|
516 l = PyList_GET_SIZE(heads); |
2a3010ba6f52
reachableroots: give anonymous name to short-lived "numheads" variable
Yuya Nishihara <yuya@tcha.org>
parents:
26041
diff
changeset
|
517 for (i = 0; i < l; i++) { |
26018
c6115c30a376
reachableroots: verify type of each item of heads argument
Yuya Nishihara <yuya@tcha.org>
parents:
26017
diff
changeset
|
518 revnum = PyInt_AsLong(PyList_GET_ITEM(heads, i)); |
c6115c30a376
reachableroots: verify type of each item of heads argument
Yuya Nishihara <yuya@tcha.org>
parents:
26017
diff
changeset
|
519 if (revnum == -1 && PyErr_Occurred()) |
c6115c30a376
reachableroots: verify type of each item of heads argument
Yuya Nishihara <yuya@tcha.org>
parents:
26017
diff
changeset
|
520 goto bail; |
26017
44705659da94
reachableroots: verify integer range of heads argument (issue4775)
Yuya Nishihara <yuya@tcha.org>
parents:
26016
diff
changeset
|
521 if (revnum + 1 < 0 || revnum + 1 >= len + 1) { |
44705659da94
reachableroots: verify integer range of heads argument (issue4775)
Yuya Nishihara <yuya@tcha.org>
parents:
26016
diff
changeset
|
522 PyErr_SetString(PyExc_IndexError, "head out of range"); |
44705659da94
reachableroots: verify integer range of heads argument (issue4775)
Yuya Nishihara <yuya@tcha.org>
parents:
26016
diff
changeset
|
523 goto bail; |
44705659da94
reachableroots: verify integer range of heads argument (issue4775)
Yuya Nishihara <yuya@tcha.org>
parents:
26016
diff
changeset
|
524 } |
26044
b3ad349d0e50
reachableroots: extend "revstates" to array of bit flags
Yuya Nishihara <yuya@tcha.org>
parents:
26043
diff
changeset
|
525 if (!(revstates[revnum + 1] & RS_SEEN)) { |
26080
83c9edcac05c
reachableroots: silence warning of implicit integer narrowing issued by clang
Yuya Nishihara <yuya@tcha.org>
parents:
26079
diff
changeset
|
526 tovisit[lentovisit++] = (int)revnum; |
26044
b3ad349d0e50
reachableroots: extend "revstates" to array of bit flags
Yuya Nishihara <yuya@tcha.org>
parents:
26043
diff
changeset
|
527 revstates[revnum + 1] |= RS_SEEN; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
528 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
529 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
530 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
531 /* Visit the tovisit list and find the reachable roots */ |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
532 k = 0; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
533 while (k < lentovisit) { |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
534 /* Add the node to reachable if it is a root*/ |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
535 revnum = tovisit[k++]; |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
536 if (revstates[revnum + 1] & RS_ROOT) { |
26054
5049e10fed14
reachableroots: use internal "revstates" array to test if rev is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26053
diff
changeset
|
537 revstates[revnum + 1] |= RS_REACHABLE; |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
538 val = PyInt_FromLong(revnum); |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
539 if (val == NULL) |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
540 goto bail; |
26058
e7fe0a12376c
reachableroots: handle error of PyList_Append()
Yuya Nishihara <yuya@tcha.org>
parents:
26055
diff
changeset
|
541 r = PyList_Append(reachable, val); |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
542 Py_DECREF(val); |
26058
e7fe0a12376c
reachableroots: handle error of PyList_Append()
Yuya Nishihara <yuya@tcha.org>
parents:
26055
diff
changeset
|
543 if (r < 0) |
e7fe0a12376c
reachableroots: handle error of PyList_Append()
Yuya Nishihara <yuya@tcha.org>
parents:
26055
diff
changeset
|
544 goto bail; |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
545 if (includepath == 0) |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
546 continue; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
547 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
548 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
549 /* Add its parents to the list of nodes to visit */ |
26041
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
550 if (revnum == -1) |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
551 continue; |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
552 r = index_get_parents(self, revnum, parents, (int)len - 1); |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
553 if (r < 0) |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
554 goto bail; |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
555 for (i = 0; i < 2; i++) { |
26044
b3ad349d0e50
reachableroots: extend "revstates" to array of bit flags
Yuya Nishihara <yuya@tcha.org>
parents:
26043
diff
changeset
|
556 if (!(revstates[parents[i] + 1] & RS_SEEN) |
26041
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
557 && parents[i] >= minroot) { |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
558 tovisit[lentovisit++] = parents[i]; |
26044
b3ad349d0e50
reachableroots: extend "revstates" to array of bit flags
Yuya Nishihara <yuya@tcha.org>
parents:
26043
diff
changeset
|
559 revstates[parents[i] + 1] |= RS_SEEN; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
560 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
561 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
562 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
563 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
564 /* Find all the nodes in between the roots we found and the heads |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
565 * and add them to the reachable set */ |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
566 if (includepath == 1) { |
26080
83c9edcac05c
reachableroots: silence warning of implicit integer narrowing issued by clang
Yuya Nishihara <yuya@tcha.org>
parents:
26079
diff
changeset
|
567 long minidx = minroot; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
568 if (minidx < 0) |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
569 minidx = 0; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
570 for (i = minidx; i < len; i++) { |
26044
b3ad349d0e50
reachableroots: extend "revstates" to array of bit flags
Yuya Nishihara <yuya@tcha.org>
parents:
26043
diff
changeset
|
571 if (!(revstates[i + 1] & RS_SEEN)) |
26041
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
572 continue; |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
573 r = index_get_parents(self, i, parents, (int)len - 1); |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
574 /* Corrupted index file, error is set from |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
575 * index_get_parents */ |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
576 if (r < 0) |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
577 goto bail; |
26059
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
578 if (((revstates[parents[0] + 1] | |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
579 revstates[parents[1] + 1]) & RS_REACHABLE) |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
580 && !(revstates[i + 1] & RS_REACHABLE)) { |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
581 revstates[i + 1] |= RS_REACHABLE; |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
582 val = PyInt_FromLong(i); |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
583 if (val == NULL) |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
584 goto bail; |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
585 r = PyList_Append(reachable, val); |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
586 Py_DECREF(val); |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
587 if (r < 0) |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
588 goto bail; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
589 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
590 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
591 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
592 |
26043
f2f0a3ab6e41
reachableroots: rename "seen" array to "revstates" for future extension
Yuya Nishihara <yuya@tcha.org>
parents:
26042
diff
changeset
|
593 free(revstates); |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
594 free(tovisit); |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
595 return reachable; |
26016
c8d41c9c23c7
reachableroots: unify bail cases to raise exception correctly
Yuya Nishihara <yuya@tcha.org>
parents:
26015
diff
changeset
|
596 bail: |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
597 Py_XDECREF(reachable); |
26043
f2f0a3ab6e41
reachableroots: rename "seen" array to "revstates" for future extension
Yuya Nishihara <yuya@tcha.org>
parents:
26042
diff
changeset
|
598 free(revstates); |
26016
c8d41c9c23c7
reachableroots: unify bail cases to raise exception correctly
Yuya Nishihara <yuya@tcha.org>
parents:
26015
diff
changeset
|
599 free(tovisit); |
26010
2c03e521a0c5
reachableroots: return NULL if we're throwing an exception
Augie Fackler <augie@google.com>
parents:
26009
diff
changeset
|
600 return NULL; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
601 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
602 |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
603 static PyObject *compute_phases_map_sets(indexObject *self, PyObject *args) |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
604 { |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
605 PyObject *roots = Py_None; |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
606 PyObject *ret = NULL; |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34861
diff
changeset
|
607 PyObject *phasessize = NULL; |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
608 PyObject *phaseroots = NULL; |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
609 PyObject *phaseset = NULL; |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
610 PyObject *phasessetlist = NULL; |
25911
f4386cb3252e
parsers: fix memory leak in compute_phases_map_sets
Laurent Charignon <lcharignon@fb.com>
parents:
25860
diff
changeset
|
611 PyObject *rev = NULL; |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
612 Py_ssize_t len = index_length(self); |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
613 Py_ssize_t numphase = 0; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
614 Py_ssize_t minrevallphases = 0; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
615 Py_ssize_t minrevphase = 0; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
616 Py_ssize_t i = 0; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
617 char *phases = NULL; |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
618 long phase; |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
619 |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
620 if (!PyArg_ParseTuple(args, "O", &roots)) |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
621 goto done; |
36623
a472a897c340
cext: fix computephasesmapsets() not to return without setting an exception
Yuya Nishihara <yuya@tcha.org>
parents:
36621
diff
changeset
|
622 if (roots == NULL || !PyList_Check(roots)) { |
a472a897c340
cext: fix computephasesmapsets() not to return without setting an exception
Yuya Nishihara <yuya@tcha.org>
parents:
36621
diff
changeset
|
623 PyErr_SetString(PyExc_TypeError, "roots must be a list"); |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
624 goto done; |
36623
a472a897c340
cext: fix computephasesmapsets() not to return without setting an exception
Yuya Nishihara <yuya@tcha.org>
parents:
36621
diff
changeset
|
625 } |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
626 |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
627 phases = calloc(len, 1); /* phase per rev: {0: public, 1: draft, 2: secret} */ |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
628 if (phases == NULL) { |
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
629 PyErr_NoMemory(); |
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
630 goto done; |
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
631 } |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
632 /* Put the phase information of all the roots in phases */ |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
633 numphase = PyList_GET_SIZE(roots)+1; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
634 minrevallphases = len + 1; |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
635 phasessetlist = PyList_New(numphase); |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
636 if (phasessetlist == NULL) |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
637 goto done; |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
638 |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
639 PyList_SET_ITEM(phasessetlist, 0, Py_None); |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
640 Py_INCREF(Py_None); |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
641 |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
642 for (i = 0; i < numphase-1; i++) { |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
643 phaseroots = PyList_GET_ITEM(roots, i); |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
644 phaseset = PySet_New(NULL); |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
645 if (phaseset == NULL) |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
646 goto release; |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
647 PyList_SET_ITEM(phasessetlist, i+1, phaseset); |
36623
a472a897c340
cext: fix computephasesmapsets() not to return without setting an exception
Yuya Nishihara <yuya@tcha.org>
parents:
36621
diff
changeset
|
648 if (!PyList_Check(phaseroots)) { |
a472a897c340
cext: fix computephasesmapsets() not to return without setting an exception
Yuya Nishihara <yuya@tcha.org>
parents:
36621
diff
changeset
|
649 PyErr_SetString(PyExc_TypeError, |
a472a897c340
cext: fix computephasesmapsets() not to return without setting an exception
Yuya Nishihara <yuya@tcha.org>
parents:
36621
diff
changeset
|
650 "roots item must be a list"); |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
651 goto release; |
36623
a472a897c340
cext: fix computephasesmapsets() not to return without setting an exception
Yuya Nishihara <yuya@tcha.org>
parents:
36621
diff
changeset
|
652 } |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
653 minrevphase = add_roots_get_min(self, phaseroots, i+1, phases); |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
654 if (minrevphase == -2) /* Error from add_roots_get_min */ |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
655 goto release; |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
656 minrevallphases = MIN(minrevallphases, minrevphase); |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
657 } |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
658 /* Propagate the phase information from the roots to the revs */ |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
659 if (minrevallphases != -1) { |
25312
ee02728dd5f9
parsers: simplify the code computing the phases
Laurent Charignon <lcharignon@fb.com>
parents:
25311
diff
changeset
|
660 int parents[2]; |
ee02728dd5f9
parsers: simplify the code computing the phases
Laurent Charignon <lcharignon@fb.com>
parents:
25311
diff
changeset
|
661 for (i = minrevallphases; i < len; i++) { |
25860
895f04955a49
parsers: silence warning of implicit integer conversion issued by clang
Yuya Nishihara <yuya@tcha.org>
parents:
25810
diff
changeset
|
662 if (index_get_parents(self, i, parents, |
895f04955a49
parsers: silence warning of implicit integer conversion issued by clang
Yuya Nishihara <yuya@tcha.org>
parents:
25810
diff
changeset
|
663 (int)len - 1) < 0) |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
664 goto release; |
25312
ee02728dd5f9
parsers: simplify the code computing the phases
Laurent Charignon <lcharignon@fb.com>
parents:
25311
diff
changeset
|
665 set_phase_from_parents(phases, parents[0], parents[1], i); |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
666 } |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
667 } |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
668 /* Transform phase list to a python list */ |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34861
diff
changeset
|
669 phasessize = PyInt_FromLong(len); |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34861
diff
changeset
|
670 if (phasessize == NULL) |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
671 goto release; |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
672 for (i = 0; i < len; i++) { |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
673 phase = phases[i]; |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
674 /* We only store the sets of phase for non public phase, the public phase |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
675 * is computed as a difference */ |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
676 if (phase != 0) { |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
677 phaseset = PyList_GET_ITEM(phasessetlist, phase); |
25911
f4386cb3252e
parsers: fix memory leak in compute_phases_map_sets
Laurent Charignon <lcharignon@fb.com>
parents:
25860
diff
changeset
|
678 rev = PyInt_FromLong(i); |
27365
ec04370bdfaf
parsers: check results of PyInt_FromLong (issue4771)
Bryan O'Sullivan <bos@serpentine.com>
parents:
27364
diff
changeset
|
679 if (rev == NULL) |
ec04370bdfaf
parsers: check results of PyInt_FromLong (issue4771)
Bryan O'Sullivan <bos@serpentine.com>
parents:
27364
diff
changeset
|
680 goto release; |
25911
f4386cb3252e
parsers: fix memory leak in compute_phases_map_sets
Laurent Charignon <lcharignon@fb.com>
parents:
25860
diff
changeset
|
681 PySet_Add(phaseset, rev); |
f4386cb3252e
parsers: fix memory leak in compute_phases_map_sets
Laurent Charignon <lcharignon@fb.com>
parents:
25860
diff
changeset
|
682 Py_XDECREF(rev); |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
683 } |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
684 } |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34861
diff
changeset
|
685 ret = PyTuple_Pack(2, phasessize, phasessetlist); |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
686 |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
687 release: |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34861
diff
changeset
|
688 Py_XDECREF(phasessize); |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
689 Py_XDECREF(phasessetlist); |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
690 done: |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
691 free(phases); |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
692 return ret; |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
693 } |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
694 |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
695 static PyObject *index_headrevs(indexObject *self, PyObject *args) |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
696 { |
25297
3966e39fea98
changelog: fix bug in heads computation
Laurent Charignon <lcharignon@fb.com>
parents:
25296
diff
changeset
|
697 Py_ssize_t i, j, len; |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
698 char *nothead = NULL; |
22540
9a860ac8c216
parsers: fix uninitialize variable warning
David Soria Parra <davidsp@fb.com>
parents:
22484
diff
changeset
|
699 PyObject *heads = NULL; |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
700 PyObject *filter = NULL; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
701 PyObject *filteredrevs = Py_None; |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
702 |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
703 if (!PyArg_ParseTuple(args, "|O", &filteredrevs)) { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
704 return NULL; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
705 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
706 |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
707 if (self->headrevs && filteredrevs == self->filteredrevs) |
16787
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
708 return list_copy(self->headrevs); |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
709 |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
710 Py_DECREF(self->filteredrevs); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
711 self->filteredrevs = filteredrevs; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
712 Py_INCREF(filteredrevs); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
713 |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
714 if (filteredrevs != Py_None) { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
715 filter = PyObject_GetAttrString(filteredrevs, "__contains__"); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
716 if (!filter) { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
717 PyErr_SetString(PyExc_TypeError, |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
718 "filteredrevs has no attribute __contains__"); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
719 goto bail; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
720 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
721 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
722 |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
723 len = index_length(self); |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
724 heads = PyList_New(0); |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
725 if (heads == NULL) |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
726 goto bail; |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
727 if (len == 0) { |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
728 PyObject *nullid = PyInt_FromLong(-1); |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
729 if (nullid == NULL || PyList_Append(heads, nullid) == -1) { |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
730 Py_XDECREF(nullid); |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
731 goto bail; |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
732 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
733 goto done; |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
734 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
735 |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
736 nothead = calloc(len, 1); |
27366
7e8a883da171
parsers: add a missed PyErr_NoMemory
Bryan O'Sullivan <bos@serpentine.com>
parents:
27365
diff
changeset
|
737 if (nothead == NULL) { |
7e8a883da171
parsers: add a missed PyErr_NoMemory
Bryan O'Sullivan <bos@serpentine.com>
parents:
27365
diff
changeset
|
738 PyErr_NoMemory(); |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
739 goto bail; |
27366
7e8a883da171
parsers: add a missed PyErr_NoMemory
Bryan O'Sullivan <bos@serpentine.com>
parents:
27365
diff
changeset
|
740 } |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
741 |
28386
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
742 for (i = len - 1; i >= 0; i--) { |
25297
3966e39fea98
changelog: fix bug in heads computation
Laurent Charignon <lcharignon@fb.com>
parents:
25296
diff
changeset
|
743 int isfiltered; |
3966e39fea98
changelog: fix bug in heads computation
Laurent Charignon <lcharignon@fb.com>
parents:
25296
diff
changeset
|
744 int parents[2]; |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
745 |
28386
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
746 /* If nothead[i] == 1, it means we've seen an unfiltered child of this |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
747 * node already, and therefore this node is not filtered. So we can skip |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
748 * the expensive check_filter step. |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
749 */ |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
750 if (nothead[i] != 1) { |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
751 isfiltered = check_filter(filter, i); |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
752 if (isfiltered == -1) { |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
753 PyErr_SetString(PyExc_TypeError, |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
754 "unable to check filter"); |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
755 goto bail; |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
756 } |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
757 |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
758 if (isfiltered) { |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
759 nothead[i] = 1; |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
760 continue; |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
761 } |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
762 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
763 |
25860
895f04955a49
parsers: silence warning of implicit integer conversion issued by clang
Yuya Nishihara <yuya@tcha.org>
parents:
25810
diff
changeset
|
764 if (index_get_parents(self, i, parents, (int)len - 1) < 0) |
25810
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
765 goto bail; |
25297
3966e39fea98
changelog: fix bug in heads computation
Laurent Charignon <lcharignon@fb.com>
parents:
25296
diff
changeset
|
766 for (j = 0; j < 2; j++) { |
3966e39fea98
changelog: fix bug in heads computation
Laurent Charignon <lcharignon@fb.com>
parents:
25296
diff
changeset
|
767 if (parents[j] >= 0) |
3966e39fea98
changelog: fix bug in heads computation
Laurent Charignon <lcharignon@fb.com>
parents:
25296
diff
changeset
|
768 nothead[parents[j]] = 1; |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
769 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
770 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
771 |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
772 for (i = 0; i < len; i++) { |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
773 PyObject *head; |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
774 |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
775 if (nothead[i]) |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
776 continue; |
22400
888bc106de83
parsers: fix typing issue when constructing Python integer object
Henrik Stuart <hg@hstuart.dk>
parents:
22399
diff
changeset
|
777 head = PyInt_FromSsize_t(i); |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
778 if (head == NULL || PyList_Append(heads, head) == -1) { |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
779 Py_XDECREF(head); |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
780 goto bail; |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
781 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
782 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
783 |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
784 done: |
16787
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
785 self->headrevs = heads; |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
786 Py_XDECREF(filter); |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
787 free(nothead); |
16787
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
788 return list_copy(self->headrevs); |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
789 bail: |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
790 Py_XDECREF(filter); |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
791 Py_XDECREF(heads); |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
792 free(nothead); |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
793 return NULL; |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
794 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
795 |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
796 /** |
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
797 * Obtain the base revision index entry. |
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
798 * |
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
799 * Callers must ensure that rev >= 0 or illegal memory access may occur. |
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
800 */ |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
801 static inline int index_baserev(indexObject *self, int rev) |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
802 { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
803 const char *data; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
804 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
805 if (rev >= self->length - 1) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
806 PyObject *tuple = PyList_GET_ITEM(self->added, |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
807 rev - self->length + 1); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
808 return (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 3)); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
809 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
810 else { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
811 data = index_deref(self, rev); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
812 if (data == NULL) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
813 return -2; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
814 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
815 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
816 return getbe32(data + 16); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
817 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
818 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
819 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
820 static PyObject *index_deltachain(indexObject *self, PyObject *args) |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
821 { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
822 int rev, generaldelta; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
823 PyObject *stoparg; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
824 int stoprev, iterrev, baserev = -1; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
825 int stopped; |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
826 PyObject *chain = NULL, *result = NULL; |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
827 const Py_ssize_t length = index_length(self); |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
828 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
829 if (!PyArg_ParseTuple(args, "iOi", &rev, &stoparg, &generaldelta)) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
830 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
831 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
832 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
833 if (PyInt_Check(stoparg)) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
834 stoprev = (int)PyInt_AsLong(stoparg); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
835 if (stoprev == -1 && PyErr_Occurred()) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
836 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
837 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
838 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
839 else if (stoparg == Py_None) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
840 stoprev = -2; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
841 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
842 else { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
843 PyErr_SetString(PyExc_ValueError, |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
844 "stoprev must be integer or None"); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
845 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
846 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
847 |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
848 if (rev < 0 || rev >= length) { |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
849 PyErr_SetString(PyExc_ValueError, "revlog index out of range"); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
850 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
851 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
852 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
853 chain = PyList_New(0); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
854 if (chain == NULL) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
855 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
856 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
857 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
858 baserev = index_baserev(self, rev); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
859 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
860 /* This should never happen. */ |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
861 if (baserev <= -2) { |
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
862 /* Error should be set by index_deref() */ |
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
863 assert(PyErr_Occurred()); |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
864 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
865 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
866 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
867 iterrev = rev; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
868 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
869 while (iterrev != baserev && iterrev != stoprev) { |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
870 PyObject *value = PyInt_FromLong(iterrev); |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
871 if (value == NULL) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
872 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
873 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
874 if (PyList_Append(chain, value)) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
875 Py_DECREF(value); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
876 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
877 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
878 Py_DECREF(value); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
879 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
880 if (generaldelta) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
881 iterrev = baserev; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
882 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
883 else { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
884 iterrev--; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
885 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
886 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
887 if (iterrev < 0) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
888 break; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
889 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
890 |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
891 if (iterrev >= length) { |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
892 PyErr_SetString(PyExc_IndexError, "revision outside index"); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
893 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
894 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
895 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
896 baserev = index_baserev(self, iterrev); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
897 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
898 /* This should never happen. */ |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
899 if (baserev <= -2) { |
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
900 /* Error should be set by index_deref() */ |
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
901 assert(PyErr_Occurred()); |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
902 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
903 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
904 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
905 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
906 if (iterrev == stoprev) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
907 stopped = 1; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
908 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
909 else { |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
910 PyObject *value = PyInt_FromLong(iterrev); |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
911 if (value == NULL) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
912 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
913 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
914 if (PyList_Append(chain, value)) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
915 Py_DECREF(value); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
916 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
917 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
918 Py_DECREF(value); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
919 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
920 stopped = 0; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
921 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
922 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
923 if (PyList_Reverse(chain)) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
924 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
925 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
926 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
927 result = Py_BuildValue("OO", chain, stopped ? Py_True : Py_False); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
928 Py_DECREF(chain); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
929 return result; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
930 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
931 bail: |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
932 Py_DECREF(chain); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
933 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
934 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
935 |
16618
6bae941b58ad
parsers: change the type of nt_level
Bryan O'Sullivan <bryano@fb.com>
parents:
16617
diff
changeset
|
936 static inline int nt_level(const char *node, Py_ssize_t level) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
937 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
938 int v = node[level>>1]; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
939 if (!(level & 1)) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
940 v >>= 4; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
941 return v & 0xf; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
942 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
943 |
16616
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
944 /* |
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
945 * Return values: |
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
946 * |
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
947 * -4: match is ambiguous (multiple candidates) |
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
948 * -2: not found |
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
949 * rest: valid rev |
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
950 */ |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
951 static int nt_find(nodetree *self, const char *node, Py_ssize_t nodelen, |
16663 | 952 int hex) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
953 { |
16663 | 954 int (*getnybble)(const char *, Py_ssize_t) = hex ? hexdigit : nt_level; |
16641
e6dfbc5df76f
parsers: use the correct maximum radix tree depth
Bryan O'Sullivan <bryano@fb.com>
parents:
16604
diff
changeset
|
955 int level, maxlevel, off; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
956 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
957 if (nodelen == 20 && node[0] == '\0' && memcmp(node, nullid, 20) == 0) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
958 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
959 |
16663 | 960 if (hex) |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
961 maxlevel = nodelen > 40 ? 40 : (int)nodelen; |
16663 | 962 else |
963 maxlevel = nodelen > 20 ? 40 : ((int)nodelen * 2); | |
16641
e6dfbc5df76f
parsers: use the correct maximum radix tree depth
Bryan O'Sullivan <bryano@fb.com>
parents:
16604
diff
changeset
|
964 |
e6dfbc5df76f
parsers: use the correct maximum radix tree depth
Bryan O'Sullivan <bryano@fb.com>
parents:
16604
diff
changeset
|
965 for (level = off = 0; level < maxlevel; level++) { |
16663 | 966 int k = getnybble(node, level); |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
967 nodetreenode *n = &self->nodes[off]; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
968 int v = n->children[k]; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
969 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
970 if (v < 0) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
971 const char *n; |
16663 | 972 Py_ssize_t i; |
973 | |
38846
f738c502e43b
index: store nullrev as -1 in nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38845
diff
changeset
|
974 v = -(v + 2); |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
975 n = index_node(self->index, v); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
976 if (n == NULL) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
977 return -2; |
16663 | 978 for (i = level; i < maxlevel; i++) |
979 if (getnybble(node, i) != nt_level(n, i)) | |
980 return -2; | |
981 return v; | |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
982 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
983 if (v == 0) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
984 return -2; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
985 off = v; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
986 } |
16616
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
987 /* multiple matches against an ambiguous prefix */ |
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
988 return -4; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
989 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
990 |
38915
fff675dfb80b
index: pass only nodetree to nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38914
diff
changeset
|
991 static int nt_new(nodetree *self) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
992 { |
38915
fff675dfb80b
index: pass only nodetree to nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38914
diff
changeset
|
993 if (self->length == self->capacity) { |
38938
dcd395dc98d8
index: remove side-effect from failed nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38937
diff
changeset
|
994 unsigned newcapacity; |
dcd395dc98d8
index: remove side-effect from failed nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38937
diff
changeset
|
995 nodetreenode *newnodes; |
38915
fff675dfb80b
index: pass only nodetree to nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38914
diff
changeset
|
996 if (self->capacity >= INT_MAX / (sizeof(nodetreenode) * 2)) { |
24623
2262d7bc469e
parsers: check for memory allocation overflows more carefully
Bryan O'Sullivan <bryano@fb.com>
parents:
24622
diff
changeset
|
997 PyErr_SetString(PyExc_MemoryError, |
2262d7bc469e
parsers: check for memory allocation overflows more carefully
Bryan O'Sullivan <bryano@fb.com>
parents:
24622
diff
changeset
|
998 "overflow in nt_new"); |
2262d7bc469e
parsers: check for memory allocation overflows more carefully
Bryan O'Sullivan <bryano@fb.com>
parents:
24622
diff
changeset
|
999 return -1; |
2262d7bc469e
parsers: check for memory allocation overflows more carefully
Bryan O'Sullivan <bryano@fb.com>
parents:
24622
diff
changeset
|
1000 } |
38938
dcd395dc98d8
index: remove side-effect from failed nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38937
diff
changeset
|
1001 newcapacity = self->capacity * 2; |
dcd395dc98d8
index: remove side-effect from failed nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38937
diff
changeset
|
1002 newnodes = realloc(self->nodes, newcapacity * sizeof(nodetreenode)); |
dcd395dc98d8
index: remove side-effect from failed nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38937
diff
changeset
|
1003 if (newnodes == NULL) { |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1004 PyErr_SetString(PyExc_MemoryError, "out of memory"); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1005 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1006 } |
38938
dcd395dc98d8
index: remove side-effect from failed nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38937
diff
changeset
|
1007 self->capacity = newcapacity; |
dcd395dc98d8
index: remove side-effect from failed nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38937
diff
changeset
|
1008 self->nodes = newnodes; |
38915
fff675dfb80b
index: pass only nodetree to nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38914
diff
changeset
|
1009 memset(&self->nodes[self->length], 0, |
fff675dfb80b
index: pass only nodetree to nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38914
diff
changeset
|
1010 sizeof(nodetreenode) * (self->capacity - self->length)); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1011 } |
38915
fff675dfb80b
index: pass only nodetree to nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38914
diff
changeset
|
1012 return self->length++; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1013 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1014 |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1015 static int nt_insert(nodetree *self, const char *node, int rev) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1016 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1017 int level = 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1018 int off = 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1019 |
16641
e6dfbc5df76f
parsers: use the correct maximum radix tree depth
Bryan O'Sullivan <bryano@fb.com>
parents:
16604
diff
changeset
|
1020 while (level < 40) { |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1021 int k = nt_level(node, level); |
38912
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
1022 nodetreenode *n; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1023 int v; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1024 |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1025 n = &self->nodes[off]; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1026 v = n->children[k]; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1027 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1028 if (v == 0) { |
38846
f738c502e43b
index: store nullrev as -1 in nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38845
diff
changeset
|
1029 n->children[k] = -rev - 2; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1030 return 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1031 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1032 if (v < 0) { |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1033 const char *oldnode = index_node_existing(self->index, -(v + 2)); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1034 int noff; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1035 |
37999
514605777244
revlog: handle errors from index_node() in nt_insert() and index_slice_del()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37978
diff
changeset
|
1036 if (oldnode == NULL) |
514605777244
revlog: handle errors from index_node() in nt_insert() and index_slice_del()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37978
diff
changeset
|
1037 return -1; |
514605777244
revlog: handle errors from index_node() in nt_insert() and index_slice_del()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37978
diff
changeset
|
1038 if (!memcmp(oldnode, node, 20)) { |
38846
f738c502e43b
index: store nullrev as -1 in nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38845
diff
changeset
|
1039 n->children[k] = -rev - 2; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1040 return 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1041 } |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1042 noff = nt_new(self); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1043 if (noff == -1) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1044 return -1; |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1045 /* self->nodes may have been changed by realloc */ |
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1046 self->nodes[off].children[k] = noff; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1047 off = noff; |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1048 n = &self->nodes[off]; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1049 n->children[nt_level(oldnode, ++level)] = v; |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1050 if (level > self->depth) |
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1051 self->depth = level; |
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1052 self->splits += 1; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1053 } else { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1054 level += 1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1055 off = v; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1056 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1057 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1058 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1059 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1060 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1061 |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1062 static int nt_delete_node(nodetree *self, const char *node) |
38845
f9fc59ea3135
index: create function for deleting node from nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38821
diff
changeset
|
1063 { |
38846
f738c502e43b
index: store nullrev as -1 in nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38845
diff
changeset
|
1064 /* rev==-2 happens to get encoded as 0, which is interpreted as not set */ |
f738c502e43b
index: store nullrev as -1 in nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38845
diff
changeset
|
1065 return nt_insert(self, node, -2); |
38845
f9fc59ea3135
index: create function for deleting node from nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38821
diff
changeset
|
1066 } |
f9fc59ea3135
index: create function for deleting node from nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38821
diff
changeset
|
1067 |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1068 static int nt_init(nodetree *self, indexObject *index, unsigned capacity) |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1069 { |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1070 self->index = index; |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1071 self->capacity = capacity; |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1072 self->depth = 0; |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1073 self->splits = 0; |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1074 self->nodes = calloc(self->capacity, sizeof(nodetreenode)); |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1075 if (self->nodes == NULL) { |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1076 PyErr_NoMemory(); |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1077 return -1; |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1078 } |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1079 self->length = 1; |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1080 if (nt_insert(self, nullid, -1) == -1) { |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1081 free(self->nodes); |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1082 return -1; |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1083 } |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1084 return 0; |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1085 } |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1086 |
38943
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1087 static int nt_partialmatch(nodetree *self, const char *node, |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1088 Py_ssize_t nodelen) |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1089 { |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1090 return nt_find(self, node, nodelen, 1); |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1091 } |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1092 |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1093 /* |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1094 * Find the length of the shortest unique prefix of node. |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1095 * |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1096 * Return values: |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1097 * |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1098 * -3: error (exception set) |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1099 * -2: not found (no exception set) |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1100 * rest: length of shortest prefix |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1101 */ |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1102 static int nt_shortest(nodetree *self, const char *node) |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1103 { |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1104 int level, off; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1105 |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1106 for (level = off = 0; level < 40; level++) { |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1107 int k, v; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1108 nodetreenode *n = &self->nodes[off]; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1109 k = nt_level(node, level); |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1110 v = n->children[k]; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1111 if (v < 0) { |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1112 const char *n; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1113 v = -(v + 2); |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1114 n = index_node_existing(self->index, v); |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1115 if (n == NULL) |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1116 return -3; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1117 if (memcmp(node, n, 20) != 0) |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1118 /* |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1119 * Found a unique prefix, but it wasn't for the |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1120 * requested node (i.e the requested node does |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1121 * not exist). |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1122 */ |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1123 return -2; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1124 return level + 1; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1125 } |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1126 if (v == 0) |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1127 return -2; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1128 off = v; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1129 } |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1130 /* |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1131 * The node was still not unique after 40 hex digits, so this won't |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1132 * happen. Also, if we get here, then there's a programming error in |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1133 * this file that made us insert a node longer than 40 hex digits. |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1134 */ |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1135 PyErr_SetString(PyExc_Exception, "broken node tree"); |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1136 return -3; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1137 } |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1138 |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1139 static int index_init_nt(indexObject *self) |
16615
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1140 { |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1141 if (self->nt == NULL) { |
38937
f7d8fb2ed8a8
index: remove side-effect from failed nt_init()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38936
diff
changeset
|
1142 if ((size_t)self->raw_length > INT_MAX / sizeof(nodetreenode)) { |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1143 PyErr_SetString(PyExc_ValueError, "overflow in index_init_nt"); |
38937
f7d8fb2ed8a8
index: remove side-effect from failed nt_init()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38936
diff
changeset
|
1144 return -1; |
f7d8fb2ed8a8
index: remove side-effect from failed nt_init()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38936
diff
changeset
|
1145 } |
38912
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
1146 self->nt = PyMem_Malloc(sizeof(nodetree)); |
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
1147 if (self->nt == NULL) { |
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
1148 PyErr_NoMemory(); |
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
1149 return -1; |
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
1150 } |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1151 unsigned capacity = (self->raw_length < 4 ? 4 : (int)self->raw_length / 2); |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1152 if (nt_init(self->nt, self, capacity) == -1) { |
38936
05c1f5f49ebb
index: use PyMem_Free() to free nodeetree instance
Martin von Zweigbergk <martinvonz@google.com>
parents:
38915
diff
changeset
|
1153 PyMem_Free(self->nt); |
38912
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
1154 self->nt = NULL; |
16615
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1155 return -1; |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1156 } |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
1157 self->ntrev = (int)index_length(self); |
16615
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1158 self->ntlookups = 1; |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1159 self->ntmisses = 0; |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1160 } |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1161 return 0; |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1162 } |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1163 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1164 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1165 * Return values: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1166 * |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1167 * -3: error (exception set) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1168 * -2: not found (no exception set) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1169 * rest: valid rev |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1170 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1171 static int index_find_node(indexObject *self, |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1172 const char *node, Py_ssize_t nodelen) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1173 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1174 int rev; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1175 |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1176 if (index_init_nt(self) == -1) |
38820
44bbc89ec5e0
revlog: remove micro-optimization for looking up only nullid
Martin von Zweigbergk <martinvonz@google.com>
parents:
38819
diff
changeset
|
1177 return -3; |
44bbc89ec5e0
revlog: remove micro-optimization for looking up only nullid
Martin von Zweigbergk <martinvonz@google.com>
parents:
38819
diff
changeset
|
1178 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1179 self->ntlookups++; |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1180 rev = nt_find(self->nt, node, nodelen, 0); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1181 if (rev >= -1) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1182 return rev; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1183 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1184 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1185 * For the first handful of lookups, we scan the entire index, |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1186 * and cache only the matching nodes. This optimizes for cases |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1187 * like "hg tip", where only a few nodes are accessed. |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1188 * |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1189 * After that, we cache every node we visit, using a single |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1190 * scan amortized over multiple lookups. This gives the best |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1191 * bulk performance, e.g. for "hg log". |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1192 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1193 if (self->ntmisses++ < 4) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1194 for (rev = self->ntrev - 1; rev >= 0; rev--) { |
37861
a9d9802d577e
revlog: don't say "not found" on internal error
Martin von Zweigbergk <martinvonz@google.com>
parents:
37860
diff
changeset
|
1195 const char *n = index_node_existing(self, rev); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1196 if (n == NULL) |
37861
a9d9802d577e
revlog: don't say "not found" on internal error
Martin von Zweigbergk <martinvonz@google.com>
parents:
37860
diff
changeset
|
1197 return -3; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1198 if (memcmp(node, n, nodelen > 20 ? 20 : nodelen) == 0) { |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1199 if (nt_insert(self->nt, n, rev) == -1) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1200 return -3; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1201 break; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1202 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1203 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1204 } else { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1205 for (rev = self->ntrev - 1; rev >= 0; rev--) { |
37861
a9d9802d577e
revlog: don't say "not found" on internal error
Martin von Zweigbergk <martinvonz@google.com>
parents:
37860
diff
changeset
|
1206 const char *n = index_node_existing(self, rev); |
a9d9802d577e
revlog: don't say "not found" on internal error
Martin von Zweigbergk <martinvonz@google.com>
parents:
37860
diff
changeset
|
1207 if (n == NULL) |
a9d9802d577e
revlog: don't say "not found" on internal error
Martin von Zweigbergk <martinvonz@google.com>
parents:
37860
diff
changeset
|
1208 return -3; |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1209 if (nt_insert(self->nt, n, rev) == -1) { |
16614
1d800eb9ba52
parsers: update ntrev when we stop scanning
Bryan O'Sullivan <bryano@fb.com>
parents:
16597
diff
changeset
|
1210 self->ntrev = rev + 1; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1211 return -3; |
16614
1d800eb9ba52
parsers: update ntrev when we stop scanning
Bryan O'Sullivan <bryano@fb.com>
parents:
16597
diff
changeset
|
1212 } |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1213 if (memcmp(node, n, nodelen > 20 ? 20 : nodelen) == 0) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1214 break; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1215 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1216 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1217 self->ntrev = rev; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1218 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1219 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1220 if (rev >= 0) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1221 return rev; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1222 return -2; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1223 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1224 |
25561
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1225 static void raise_revlog_error(void) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1226 { |
25561
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1227 PyObject *mod = NULL, *dict = NULL, *errclass = NULL; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1228 |
25561
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1229 mod = PyImport_ImportModule("mercurial.error"); |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1230 if (mod == NULL) { |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1231 goto cleanup; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1232 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1233 |
25561
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1234 dict = PyModule_GetDict(mod); |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1235 if (dict == NULL) { |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1236 goto cleanup; |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1237 } |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1238 Py_INCREF(dict); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1239 |
25561
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1240 errclass = PyDict_GetItemString(dict, "RevlogError"); |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1241 if (errclass == NULL) { |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1242 PyErr_SetString(PyExc_SystemError, |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1243 "could not find RevlogError"); |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1244 goto cleanup; |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1245 } |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1246 |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1247 /* value of exception is ignored by callers */ |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1248 PyErr_SetString(errclass, "RevlogError"); |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1249 |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1250 cleanup: |
50a6c3c55db1
parsers: do not cache RevlogError type (issue4451)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24879
diff
changeset
|
1251 Py_XDECREF(dict); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1252 Py_XDECREF(mod); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1253 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1254 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1255 static PyObject *index_getitem(indexObject *self, PyObject *value) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1256 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1257 char *node; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1258 int rev; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1259 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1260 if (PyInt_Check(value)) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1261 return index_get(self, PyInt_AS_LONG(value)); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1262 |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
1263 if (node_check(value, &node) == -1) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1264 return NULL; |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
1265 rev = index_find_node(self, node, 20); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1266 if (rev >= -1) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1267 return PyInt_FromLong(rev); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1268 if (rev == -2) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1269 raise_revlog_error(); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1270 return NULL; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1271 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1272 |
37929
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1273 /* |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1274 * Fully populate the radix tree. |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1275 */ |
38942
3e74c01102af
index: rename "nt_*(indexObject *self,...)" functions to "index_*"
Martin von Zweigbergk <martinvonz@google.com>
parents:
38941
diff
changeset
|
1276 static int index_populate_nt(indexObject *self) { |
37929
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1277 int rev; |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1278 if (self->ntrev > 0) { |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1279 for (rev = self->ntrev - 1; rev >= 0; rev--) { |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1280 const char *n = index_node_existing(self, rev); |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1281 if (n == NULL) |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1282 return -1; |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1283 if (nt_insert(self->nt, n, rev) == -1) |
37929
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1284 return -1; |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1285 } |
37930
892592475094
revlog: use literal -1 instead of variable that always has that value
Martin von Zweigbergk <martinvonz@google.com>
parents:
37929
diff
changeset
|
1286 self->ntrev = -1; |
37929
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1287 } |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1288 return 0; |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1289 } |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1290 |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1291 static PyObject *index_partialmatch(indexObject *self, PyObject *args) |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1292 { |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1293 const char *fullnode; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1294 int nodelen; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1295 char *node; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1296 int rev, i; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1297 |
36620
186c6df3a373
py3: bulk-replace 'const char*' format specifier passed to PyArg_ParseTuple*()
Yuya Nishihara <yuya@tcha.org>
parents:
36619
diff
changeset
|
1298 if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &node, &nodelen)) |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1299 return NULL; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1300 |
37858
92ed344a9e64
revlog: use radix tree also for matching keys shorter than 4 hex digits
Martin von Zweigbergk <martinvonz@google.com>
parents:
36623
diff
changeset
|
1301 if (nodelen < 1) { |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1302 PyErr_SetString(PyExc_ValueError, "key too short"); |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1303 return NULL; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1304 } |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1305 |
17353
bde1185f406c
revlog: don't try to partialmatch strings those length > 40
sorcerer
parents:
17165
diff
changeset
|
1306 if (nodelen > 40) { |
bde1185f406c
revlog: don't try to partialmatch strings those length > 40
sorcerer
parents:
17165
diff
changeset
|
1307 PyErr_SetString(PyExc_ValueError, "key too long"); |
bde1185f406c
revlog: don't try to partialmatch strings those length > 40
sorcerer
parents:
17165
diff
changeset
|
1308 return NULL; |
bde1185f406c
revlog: don't try to partialmatch strings those length > 40
sorcerer
parents:
17165
diff
changeset
|
1309 } |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1310 |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1311 for (i = 0; i < nodelen; i++) |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1312 hexdigit(node, i); |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1313 if (PyErr_Occurred()) { |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1314 /* input contains non-hex characters */ |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1315 PyErr_Clear(); |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1316 Py_RETURN_NONE; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1317 } |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1318 |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1319 if (index_init_nt(self) == -1) |
38911
2aa4f06c1e91
index: make "nt_*" functions work on an initialized nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38868
diff
changeset
|
1320 return NULL; |
38942
3e74c01102af
index: rename "nt_*(indexObject *self,...)" functions to "index_*"
Martin von Zweigbergk <martinvonz@google.com>
parents:
38941
diff
changeset
|
1321 if (index_populate_nt(self) == -1) |
38911
2aa4f06c1e91
index: make "nt_*" functions work on an initialized nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38868
diff
changeset
|
1322 return NULL; |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1323 rev = nt_partialmatch(self->nt, node, nodelen); |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1324 |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1325 switch (rev) { |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1326 case -4: |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1327 raise_revlog_error(); |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1328 return NULL; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1329 case -2: |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1330 Py_RETURN_NONE; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1331 case -1: |
30100
c5afe5531709
parsers: convert PyString* to PyBytes*
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30090
diff
changeset
|
1332 return PyBytes_FromStringAndSize(nullid, 20); |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1333 } |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1334 |
37860
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
1335 fullnode = index_node_existing(self, rev); |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1336 if (fullnode == NULL) { |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1337 return NULL; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1338 } |
30100
c5afe5531709
parsers: convert PyString* to PyBytes*
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30090
diff
changeset
|
1339 return PyBytes_FromStringAndSize(fullnode, 20); |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1340 } |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1341 |
37968
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1342 static PyObject *index_shortest(indexObject *self, PyObject *args) |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1343 { |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1344 PyObject *val; |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1345 char *node; |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1346 int length; |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1347 |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1348 if (!PyArg_ParseTuple(args, "O", &val)) |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1349 return NULL; |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
1350 if (node_check(val, &node) == -1) |
37968
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1351 return NULL; |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1352 |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1353 self->ntlookups++; |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1354 if (index_init_nt(self) == -1) |
38911
2aa4f06c1e91
index: make "nt_*" functions work on an initialized nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38868
diff
changeset
|
1355 return NULL; |
38942
3e74c01102af
index: rename "nt_*(indexObject *self,...)" functions to "index_*"
Martin von Zweigbergk <martinvonz@google.com>
parents:
38941
diff
changeset
|
1356 if (index_populate_nt(self) == -1) |
38911
2aa4f06c1e91
index: make "nt_*" functions work on an initialized nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38868
diff
changeset
|
1357 return NULL; |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1358 length = nt_shortest(self->nt, node); |
37968
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1359 if (length == -3) |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1360 return NULL; |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1361 if (length == -2) { |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1362 raise_revlog_error(); |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1363 return NULL; |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1364 } |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1365 return PyInt_FromLong(length); |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1366 } |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
1367 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1368 static PyObject *index_m_get(indexObject *self, PyObject *args) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1369 { |
16679
2950d186a927
parsers: strictly check for 20-byte hashes where they're required
Bryan O'Sullivan <bryano@fb.com>
parents:
16641
diff
changeset
|
1370 PyObject *val; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1371 char *node; |
16679
2950d186a927
parsers: strictly check for 20-byte hashes where they're required
Bryan O'Sullivan <bryano@fb.com>
parents:
16641
diff
changeset
|
1372 int rev; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1373 |
16679
2950d186a927
parsers: strictly check for 20-byte hashes where they're required
Bryan O'Sullivan <bryano@fb.com>
parents:
16641
diff
changeset
|
1374 if (!PyArg_ParseTuple(args, "O", &val)) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1375 return NULL; |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
1376 if (node_check(val, &node) == -1) |
16679
2950d186a927
parsers: strictly check for 20-byte hashes where they're required
Bryan O'Sullivan <bryano@fb.com>
parents:
16641
diff
changeset
|
1377 return NULL; |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
1378 rev = index_find_node(self, node, 20); |
27638
90e3c5129226
cleanup: remove superfluous space after space after equals (C)
timeless <timeless@mozdev.org>
parents:
27592
diff
changeset
|
1379 if (rev == -3) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1380 return NULL; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1381 if (rev == -2) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1382 Py_RETURN_NONE; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1383 return PyInt_FromLong(rev); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1384 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1385 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1386 static int index_contains(indexObject *self, PyObject *value) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1387 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1388 char *node; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1389 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1390 if (PyInt_Check(value)) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1391 long rev = PyInt_AS_LONG(value); |
38866
aa33988ad8ab
index: return False for "len(index) in index"
Martin von Zweigbergk <martinvonz@google.com>
parents:
38852
diff
changeset
|
1392 return rev >= -1 && rev < index_length(self); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1393 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1394 |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
1395 if (node_check(value, &node) == -1) |
16679
2950d186a927
parsers: strictly check for 20-byte hashes where they're required
Bryan O'Sullivan <bryano@fb.com>
parents:
16641
diff
changeset
|
1396 return -1; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1397 |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
1398 switch (index_find_node(self, node, 20)) { |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1399 case -3: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1400 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1401 case -2: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1402 return 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1403 default: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1404 return 1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1405 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1406 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1407 |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1408 typedef uint64_t bitmask; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1409 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1410 /* |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1411 * Given a disjoint set of revs, return all candidates for the |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1412 * greatest common ancestor. In revset notation, this is the set |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1413 * "heads(::a and ::b and ...)" |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1414 */ |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1415 static PyObject *find_gca_candidates(indexObject *self, const int *revs, |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1416 int revcount) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1417 { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1418 const bitmask allseen = (1ull << revcount) - 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1419 const bitmask poison = 1ull << revcount; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1420 PyObject *gca = PyList_New(0); |
20555
4add43865a9b
ancestors: remove unnecessary handling of 'left'
Mads Kiilerich <madski@unity3d.com>
parents:
20554
diff
changeset
|
1421 int i, v, interesting; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1422 int maxrev = -1; |
22399
9f490afcb067
parsers: use bitmask type consistently in find_gca_candidates
Henrik Stuart <hg@hstuart.dk>
parents:
21871
diff
changeset
|
1423 bitmask sp; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1424 bitmask *seen; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1425 |
19727
3d07b4a2f743
parsers: correctly handle a failed allocation
Bryan O'Sullivan <bryano@fb.com>
parents:
19726
diff
changeset
|
1426 if (gca == NULL) |
3d07b4a2f743
parsers: correctly handle a failed allocation
Bryan O'Sullivan <bryano@fb.com>
parents:
19726
diff
changeset
|
1427 return PyErr_NoMemory(); |
3d07b4a2f743
parsers: correctly handle a failed allocation
Bryan O'Sullivan <bryano@fb.com>
parents:
19726
diff
changeset
|
1428 |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1429 for (i = 0; i < revcount; i++) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1430 if (revs[i] > maxrev) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1431 maxrev = revs[i]; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1432 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1433 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1434 seen = calloc(sizeof(*seen), maxrev + 1); |
19727
3d07b4a2f743
parsers: correctly handle a failed allocation
Bryan O'Sullivan <bryano@fb.com>
parents:
19726
diff
changeset
|
1435 if (seen == NULL) { |
3d07b4a2f743
parsers: correctly handle a failed allocation
Bryan O'Sullivan <bryano@fb.com>
parents:
19726
diff
changeset
|
1436 Py_DECREF(gca); |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1437 return PyErr_NoMemory(); |
19727
3d07b4a2f743
parsers: correctly handle a failed allocation
Bryan O'Sullivan <bryano@fb.com>
parents:
19726
diff
changeset
|
1438 } |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1439 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1440 for (i = 0; i < revcount; i++) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1441 seen[revs[i]] = 1ull << i; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1442 |
20555
4add43865a9b
ancestors: remove unnecessary handling of 'left'
Mads Kiilerich <madski@unity3d.com>
parents:
20554
diff
changeset
|
1443 interesting = revcount; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1444 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1445 for (v = maxrev; v >= 0 && interesting; v--) { |
22399
9f490afcb067
parsers: use bitmask type consistently in find_gca_candidates
Henrik Stuart <hg@hstuart.dk>
parents:
21871
diff
changeset
|
1446 bitmask sv = seen[v]; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1447 int parents[2]; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1448 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1449 if (!sv) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1450 continue; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1451 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1452 if (sv < poison) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1453 interesting -= 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1454 if (sv == allseen) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1455 PyObject *obj = PyInt_FromLong(v); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1456 if (obj == NULL) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1457 goto bail; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1458 if (PyList_Append(gca, obj) == -1) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1459 Py_DECREF(obj); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1460 goto bail; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1461 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1462 sv |= poison; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1463 for (i = 0; i < revcount; i++) { |
20555
4add43865a9b
ancestors: remove unnecessary handling of 'left'
Mads Kiilerich <madski@unity3d.com>
parents:
20554
diff
changeset
|
1464 if (revs[i] == v) |
4add43865a9b
ancestors: remove unnecessary handling of 'left'
Mads Kiilerich <madski@unity3d.com>
parents:
20554
diff
changeset
|
1465 goto done; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1466 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1467 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1468 } |
25810
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
1469 if (index_get_parents(self, v, parents, maxrev) < 0) |
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
1470 goto bail; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1471 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1472 for (i = 0; i < 2; i++) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1473 int p = parents[i]; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1474 if (p == -1) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1475 continue; |
19030
48d6f436363e
parsers: fix variable declaration position issue
Matt Mackall <mpm@selenic.com>
parents:
18988
diff
changeset
|
1476 sp = seen[p]; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1477 if (sv < poison) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1478 if (sp == 0) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1479 seen[p] = sv; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1480 interesting++; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1481 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1482 else if (sp != sv) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1483 seen[p] |= sv; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1484 } else { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1485 if (sp && sp < poison) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1486 interesting--; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1487 seen[p] = sv; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1488 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1489 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1490 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1491 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1492 done: |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1493 free(seen); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1494 return gca; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1495 bail: |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1496 free(seen); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1497 Py_XDECREF(gca); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1498 return NULL; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1499 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1500 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1501 /* |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1502 * Given a disjoint set of revs, return the subset with the longest |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1503 * path to the root. |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1504 */ |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1505 static PyObject *find_deepest(indexObject *self, PyObject *revs) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1506 { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1507 const Py_ssize_t revcount = PyList_GET_SIZE(revs); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1508 static const Py_ssize_t capacity = 24; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1509 int *depth, *interesting = NULL; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1510 int i, j, v, ninteresting; |
21730
8da100383dc3
parsers.c: fix a couple of memory leaks
Danek Duvall <danek.duvall@oracle.com>
parents:
21103
diff
changeset
|
1511 PyObject *dict = NULL, *keys = NULL; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1512 long *seen = NULL; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1513 int maxrev = -1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1514 long final; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1515 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1516 if (revcount > capacity) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1517 PyErr_Format(PyExc_OverflowError, |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1518 "bitset size (%ld) > capacity (%ld)", |
19062
365b0de17c1c
parsers: remove warning: format ‘%ld’ expects argument of type ‘long int’
André Sintzoff <andre.sintzoff@gmail.com>
parents:
19030
diff
changeset
|
1519 (long)revcount, (long)capacity); |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1520 return NULL; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1521 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1522 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1523 for (i = 0; i < revcount; i++) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1524 int n = (int)PyInt_AsLong(PyList_GET_ITEM(revs, i)); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1525 if (n > maxrev) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1526 maxrev = n; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1527 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1528 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1529 depth = calloc(sizeof(*depth), maxrev + 1); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1530 if (depth == NULL) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1531 return PyErr_NoMemory(); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1532 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1533 seen = calloc(sizeof(*seen), maxrev + 1); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1534 if (seen == NULL) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1535 PyErr_NoMemory(); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1536 goto bail; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1537 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1538 |
33475
f501322512b6
parsers: fix invariant bug in find_deepest (issue5623)
Sune Foldager <cryo@cyanite.org>
parents:
33174
diff
changeset
|
1539 interesting = calloc(sizeof(*interesting), 1 << revcount); |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1540 if (interesting == NULL) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1541 PyErr_NoMemory(); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1542 goto bail; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1543 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1544 |
19502
8704477ad3b6
ancestor.deepest: sort revs in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19062
diff
changeset
|
1545 if (PyList_Sort(revs) == -1) |
8704477ad3b6
ancestor.deepest: sort revs in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19062
diff
changeset
|
1546 goto bail; |
8704477ad3b6
ancestor.deepest: sort revs in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19062
diff
changeset
|
1547 |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1548 for (i = 0; i < revcount; i++) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1549 int n = (int)PyInt_AsLong(PyList_GET_ITEM(revs, i)); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1550 long b = 1l << i; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1551 depth[n] = 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1552 seen[n] = b; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1553 interesting[b] = 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1554 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1555 |
33475
f501322512b6
parsers: fix invariant bug in find_deepest (issue5623)
Sune Foldager <cryo@cyanite.org>
parents:
33174
diff
changeset
|
1556 /* invariant: ninteresting is the number of non-zero entries in |
f501322512b6
parsers: fix invariant bug in find_deepest (issue5623)
Sune Foldager <cryo@cyanite.org>
parents:
33174
diff
changeset
|
1557 * interesting. */ |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1558 ninteresting = (int)revcount; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1559 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1560 for (v = maxrev; v >= 0 && ninteresting > 1; v--) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1561 int dv = depth[v]; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1562 int parents[2]; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1563 long sv; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1564 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1565 if (dv == 0) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1566 continue; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1567 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1568 sv = seen[v]; |
25810
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
1569 if (index_get_parents(self, v, parents, maxrev) < 0) |
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
1570 goto bail; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1571 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1572 for (i = 0; i < 2; i++) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1573 int p = parents[i]; |
27341
5042b999ef0a
parsers: narrow scope of a variable to be less confusing
Bryan O'Sullivan <bos@serpentine.com>
parents:
27226
diff
changeset
|
1574 long sp; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1575 int dp; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1576 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1577 if (p == -1) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1578 continue; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1579 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1580 dp = depth[p]; |
27341
5042b999ef0a
parsers: narrow scope of a variable to be less confusing
Bryan O'Sullivan <bos@serpentine.com>
parents:
27226
diff
changeset
|
1581 sp = seen[p]; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1582 if (dp <= dv) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1583 depth[p] = dv + 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1584 if (sp != sv) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1585 interesting[sv] += 1; |
27341
5042b999ef0a
parsers: narrow scope of a variable to be less confusing
Bryan O'Sullivan <bos@serpentine.com>
parents:
27226
diff
changeset
|
1586 seen[p] = sv; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1587 if (sp) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1588 interesting[sp] -= 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1589 if (interesting[sp] == 0) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1590 ninteresting -= 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1591 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1592 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1593 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1594 else if (dv == dp - 1) { |
27341
5042b999ef0a
parsers: narrow scope of a variable to be less confusing
Bryan O'Sullivan <bos@serpentine.com>
parents:
27226
diff
changeset
|
1595 long nsp = sp | sv; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1596 if (nsp == sp) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1597 continue; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1598 seen[p] = nsp; |
19503
f2dfda6ac152
ancestor.deepest: decrement ninteresting correctly (issue3984)
Wei, Elson <elson.wei@gmail.com>
parents:
19502
diff
changeset
|
1599 interesting[sp] -= 1; |
33475
f501322512b6
parsers: fix invariant bug in find_deepest (issue5623)
Sune Foldager <cryo@cyanite.org>
parents:
33174
diff
changeset
|
1600 if (interesting[sp] == 0) |
19503
f2dfda6ac152
ancestor.deepest: decrement ninteresting correctly (issue3984)
Wei, Elson <elson.wei@gmail.com>
parents:
19502
diff
changeset
|
1601 ninteresting -= 1; |
33475
f501322512b6
parsers: fix invariant bug in find_deepest (issue5623)
Sune Foldager <cryo@cyanite.org>
parents:
33174
diff
changeset
|
1602 if (interesting[nsp] == 0) |
f501322512b6
parsers: fix invariant bug in find_deepest (issue5623)
Sune Foldager <cryo@cyanite.org>
parents:
33174
diff
changeset
|
1603 ninteresting += 1; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1604 interesting[nsp] += 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1605 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1606 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1607 interesting[sv] -= 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1608 if (interesting[sv] == 0) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1609 ninteresting -= 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1610 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1611 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1612 final = 0; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1613 j = ninteresting; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1614 for (i = 0; i < (int)(2 << revcount) && j > 0; i++) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1615 if (interesting[i] == 0) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1616 continue; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1617 final |= i; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1618 j -= 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1619 } |
21730
8da100383dc3
parsers.c: fix a couple of memory leaks
Danek Duvall <danek.duvall@oracle.com>
parents:
21103
diff
changeset
|
1620 if (final == 0) { |
8da100383dc3
parsers.c: fix a couple of memory leaks
Danek Duvall <danek.duvall@oracle.com>
parents:
21103
diff
changeset
|
1621 keys = PyList_New(0); |
8da100383dc3
parsers.c: fix a couple of memory leaks
Danek Duvall <danek.duvall@oracle.com>
parents:
21103
diff
changeset
|
1622 goto bail; |
8da100383dc3
parsers.c: fix a couple of memory leaks
Danek Duvall <danek.duvall@oracle.com>
parents:
21103
diff
changeset
|
1623 } |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1624 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1625 dict = PyDict_New(); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1626 if (dict == NULL) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1627 goto bail; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1628 |
19504
2fa303619b4d
ancestor.deepest: ignore ninteresting while building result (issue3984)
Siddharth Agarwal <sid0@fb.com>
parents:
19503
diff
changeset
|
1629 for (i = 0; i < revcount; i++) { |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1630 PyObject *key; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1631 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1632 if ((final & (1 << i)) == 0) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1633 continue; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1634 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1635 key = PyList_GET_ITEM(revs, i); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1636 Py_INCREF(key); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1637 Py_INCREF(Py_None); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1638 if (PyDict_SetItem(dict, key, Py_None) == -1) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1639 Py_DECREF(key); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1640 Py_DECREF(Py_None); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1641 goto bail; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1642 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1643 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1644 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1645 keys = PyDict_Keys(dict); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1646 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1647 bail: |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1648 free(depth); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1649 free(seen); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1650 free(interesting); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1651 Py_XDECREF(dict); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1652 |
21730
8da100383dc3
parsers.c: fix a couple of memory leaks
Danek Duvall <danek.duvall@oracle.com>
parents:
21103
diff
changeset
|
1653 return keys; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1654 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1655 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
1656 /* |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1657 * Given a (possibly overlapping) set of revs, return all the |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1658 * common ancestors heads: heads(::args[0] and ::a[1] and ...) |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1659 */ |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1660 static PyObject *index_commonancestorsheads(indexObject *self, PyObject *args) |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1661 { |
21103
628c16489d1c
parsers: remove unnecessary gca variable in index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
21102
diff
changeset
|
1662 PyObject *ret = NULL; |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1663 Py_ssize_t argcount, i, len; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1664 bitmask repeat = 0; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1665 int revcount = 0; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1666 int *revs; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1667 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1668 argcount = PySequence_Length(args); |
31469
a43fd9ec2a39
parsers: use Python memory allocator in commonancestorsheads()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31426
diff
changeset
|
1669 revs = PyMem_Malloc(argcount * sizeof(*revs)); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1670 if (argcount > 0 && revs == NULL) |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1671 return PyErr_NoMemory(); |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
1672 len = index_length(self); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1673 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1674 for (i = 0; i < argcount; i++) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1675 static const int capacity = 24; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1676 PyObject *obj = PySequence_GetItem(args, i); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1677 bitmask x; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1678 long val; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1679 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1680 if (!PyInt_Check(obj)) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1681 PyErr_SetString(PyExc_TypeError, |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1682 "arguments must all be ints"); |
23945
33d6aaf84c9e
parsers.c: fix a memory leak in index_commonancestorsheads
Augie Fackler <augie@google.com>
parents:
23944
diff
changeset
|
1683 Py_DECREF(obj); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1684 goto bail; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1685 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1686 val = PyInt_AsLong(obj); |
23945
33d6aaf84c9e
parsers.c: fix a memory leak in index_commonancestorsheads
Augie Fackler <augie@google.com>
parents:
23944
diff
changeset
|
1687 Py_DECREF(obj); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1688 if (val == -1) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1689 ret = PyList_New(0); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1690 goto done; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1691 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1692 if (val < 0 || val >= len) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1693 PyErr_SetString(PyExc_IndexError, |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1694 "index out of range"); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1695 goto bail; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1696 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1697 /* this cheesy bloom filter lets us avoid some more |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1698 * expensive duplicate checks in the common set-is-disjoint |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1699 * case */ |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1700 x = 1ull << (val & 0x3f); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1701 if (repeat & x) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1702 int k; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1703 for (k = 0; k < revcount; k++) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1704 if (val == revs[k]) |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1705 goto duplicate; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1706 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1707 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1708 else repeat |= x; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1709 if (revcount >= capacity) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1710 PyErr_Format(PyExc_OverflowError, |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1711 "bitset size (%d) > capacity (%d)", |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1712 revcount, capacity); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1713 goto bail; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1714 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1715 revs[revcount++] = (int)val; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1716 duplicate:; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1717 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1718 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1719 if (revcount == 0) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1720 ret = PyList_New(0); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1721 goto done; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1722 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1723 if (revcount == 1) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1724 PyObject *obj; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1725 ret = PyList_New(1); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1726 if (ret == NULL) |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1727 goto bail; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1728 obj = PyInt_FromLong(revs[0]); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1729 if (obj == NULL) |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1730 goto bail; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1731 PyList_SET_ITEM(ret, 0, obj); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1732 goto done; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1733 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1734 |
21103
628c16489d1c
parsers: remove unnecessary gca variable in index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
21102
diff
changeset
|
1735 ret = find_gca_candidates(self, revs, revcount); |
628c16489d1c
parsers: remove unnecessary gca variable in index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
21102
diff
changeset
|
1736 if (ret == NULL) |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1737 goto bail; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1738 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1739 done: |
31469
a43fd9ec2a39
parsers: use Python memory allocator in commonancestorsheads()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31426
diff
changeset
|
1740 PyMem_Free(revs); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1741 return ret; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1742 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1743 bail: |
31469
a43fd9ec2a39
parsers: use Python memory allocator in commonancestorsheads()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31426
diff
changeset
|
1744 PyMem_Free(revs); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1745 Py_XDECREF(ret); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1746 return NULL; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1747 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1748 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
1749 /* |
24004
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1750 * Given a (possibly overlapping) set of revs, return the greatest |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1751 * common ancestors: those with the longest path to the root. |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1752 */ |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1753 static PyObject *index_ancestors(indexObject *self, PyObject *args) |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1754 { |
26048
0be2f81aadc3
parsers: fix two leaks in index_ancestors
Augie Fackler <augie@google.com>
parents:
26044
diff
changeset
|
1755 PyObject *ret; |
24004
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1756 PyObject *gca = index_commonancestorsheads(self, args); |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1757 if (gca == NULL) |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1758 return NULL; |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1759 |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1760 if (PyList_GET_SIZE(gca) <= 1) { |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1761 return gca; |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1762 } |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1763 |
26048
0be2f81aadc3
parsers: fix two leaks in index_ancestors
Augie Fackler <augie@google.com>
parents:
26044
diff
changeset
|
1764 ret = find_deepest(self, gca); |
0be2f81aadc3
parsers: fix two leaks in index_ancestors
Augie Fackler <augie@google.com>
parents:
26044
diff
changeset
|
1765 Py_DECREF(gca); |
0be2f81aadc3
parsers: fix two leaks in index_ancestors
Augie Fackler <augie@google.com>
parents:
26044
diff
changeset
|
1766 return ret; |
24004
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1767 } |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1768 |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
1769 /* |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1770 * Invalidate any trie entries introduced by added revs. |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1771 */ |
38942
3e74c01102af
index: rename "nt_*(indexObject *self,...)" functions to "index_*"
Martin von Zweigbergk <martinvonz@google.com>
parents:
38941
diff
changeset
|
1772 static void index_invalidate_added(indexObject *self, Py_ssize_t start) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1773 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1774 Py_ssize_t i, len = PyList_GET_SIZE(self->added); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1775 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1776 for (i = start; i < len; i++) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1777 PyObject *tuple = PyList_GET_ITEM(self->added, i); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1778 PyObject *node = PyTuple_GET_ITEM(tuple, 7); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1779 |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1780 nt_delete_node(self->nt, PyBytes_AS_STRING(node)); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1781 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1782 |
16732
277e2acb7e5c
parsers: use Py_CLEAR where appropriate
Bryan O'Sullivan <bryano@fb.com>
parents:
16699
diff
changeset
|
1783 if (start == 0) |
277e2acb7e5c
parsers: use Py_CLEAR where appropriate
Bryan O'Sullivan <bryano@fb.com>
parents:
16699
diff
changeset
|
1784 Py_CLEAR(self->added); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1785 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1786 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1787 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1788 * Delete a numeric range of revs, which must be at the end of the |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1789 * range, but exclude the sentinel nullid entry. |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1790 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1791 static int index_slice_del(indexObject *self, PyObject *item) |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1792 { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1793 Py_ssize_t start, stop, step, slicelength; |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
1794 Py_ssize_t length = index_length(self) + 1; |
16784
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
1795 int ret = 0; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1796 |
30171
7a3b59f0329a
parsers: avoid PySliceObject cast on Python 3
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30169
diff
changeset
|
1797 /* Argument changed from PySliceObject* to PyObject* in Python 3. */ |
7a3b59f0329a
parsers: avoid PySliceObject cast on Python 3
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30169
diff
changeset
|
1798 #ifdef IS_PY3K |
7a3b59f0329a
parsers: avoid PySliceObject cast on Python 3
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30169
diff
changeset
|
1799 if (PySlice_GetIndicesEx(item, length, |
7a3b59f0329a
parsers: avoid PySliceObject cast on Python 3
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30169
diff
changeset
|
1800 #else |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1801 if (PySlice_GetIndicesEx((PySliceObject*)item, length, |
30171
7a3b59f0329a
parsers: avoid PySliceObject cast on Python 3
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30169
diff
changeset
|
1802 #endif |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1803 &start, &stop, &step, &slicelength) < 0) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1804 return -1; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1805 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1806 if (slicelength <= 0) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1807 return 0; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1808 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1809 if ((step < 0 && start < stop) || (step > 0 && start > stop)) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1810 stop = start; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
1811 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1812 if (step < 0) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1813 stop = start + 1; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1814 start = stop + step*(slicelength - 1) - 1; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1815 step = -step; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1816 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1817 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1818 if (step != 1) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1819 PyErr_SetString(PyExc_ValueError, |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1820 "revlog index delete requires step size of 1"); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1821 return -1; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
1822 } |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1823 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1824 if (stop != length - 1) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1825 PyErr_SetString(PyExc_IndexError, |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1826 "revlog index deletion indices are invalid"); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1827 return -1; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1828 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1829 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1830 if (start < self->length - 1) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1831 if (self->nt) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1832 Py_ssize_t i; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1833 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1834 for (i = start + 1; i < self->length - 1; i++) { |
37999
514605777244
revlog: handle errors from index_node() in nt_insert() and index_slice_del()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37978
diff
changeset
|
1835 const char *node = index_node_existing(self, i); |
514605777244
revlog: handle errors from index_node() in nt_insert() and index_slice_del()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37978
diff
changeset
|
1836 if (node == NULL) |
514605777244
revlog: handle errors from index_node() in nt_insert() and index_slice_del()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37978
diff
changeset
|
1837 return -1; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1838 |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1839 nt_delete_node(self->nt, node); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1840 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1841 if (self->added) |
38942
3e74c01102af
index: rename "nt_*(indexObject *self,...)" functions to "index_*"
Martin von Zweigbergk <martinvonz@google.com>
parents:
38941
diff
changeset
|
1842 index_invalidate_added(self, 0); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1843 if (self->ntrev > start) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1844 self->ntrev = (int)start; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1845 } |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1846 self->length = start + 1; |
18504
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
1847 if (start < self->raw_length) { |
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
1848 if (self->cache) { |
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
1849 Py_ssize_t i; |
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
1850 for (i = start; i < self->raw_length; i++) |
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
1851 Py_CLEAR(self->cache[i]); |
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
1852 } |
16784
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
1853 self->raw_length = start; |
18504
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
1854 } |
16784
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
1855 goto done; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
1856 } |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
1857 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1858 if (self->nt) { |
38942
3e74c01102af
index: rename "nt_*(indexObject *self,...)" functions to "index_*"
Martin von Zweigbergk <martinvonz@google.com>
parents:
38941
diff
changeset
|
1859 index_invalidate_added(self, start - self->length + 1); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1860 if (self->ntrev > start) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1861 self->ntrev = (int)start; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1862 } |
16784
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
1863 if (self->added) |
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
1864 ret = PyList_SetSlice(self->added, start - self->length + 1, |
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
1865 PyList_GET_SIZE(self->added), NULL); |
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
1866 done: |
16787
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
1867 Py_CLEAR(self->headrevs); |
16784
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
1868 return ret; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1869 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1870 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1871 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1872 * Supported ops: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1873 * |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1874 * slice deletion |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1875 * string assignment (extend node->rev mapping) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1876 * string deletion (shrink node->rev mapping) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1877 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1878 static int index_assign_subscript(indexObject *self, PyObject *item, |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1879 PyObject *value) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1880 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1881 char *node; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1882 long rev; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1883 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1884 if (PySlice_Check(item) && value == NULL) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1885 return index_slice_del(self, item); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1886 |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
1887 if (node_check(item, &node) == -1) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1888 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1889 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1890 if (value == NULL) |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1891 return self->nt ? nt_delete_node(self->nt, node) : 0; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1892 rev = PyInt_AsLong(value); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1893 if (rev > INT_MAX || rev < 0) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1894 if (!PyErr_Occurred()) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1895 PyErr_SetString(PyExc_ValueError, "rev out of range"); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1896 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1897 } |
23468
ee311681e591
parsers: ensure revlog index node tree is initialized before insertion
Mike Edgar <adgar@google.com>
parents:
23087
diff
changeset
|
1898 |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1899 if (index_init_nt(self) == -1) |
23468
ee311681e591
parsers: ensure revlog index node tree is initialized before insertion
Mike Edgar <adgar@google.com>
parents:
23087
diff
changeset
|
1900 return -1; |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1901 return nt_insert(self->nt, node, (int)rev); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1902 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1903 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1904 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1905 * Find all RevlogNG entries in an index that has inline data. Update |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1906 * the optional "offsets" table with those entries. |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1907 */ |
22401
9ba8a93e55f5
parsers: ensure correct return type for inline_scan
Henrik Stuart <hg@hstuart.dk>
parents:
22400
diff
changeset
|
1908 static Py_ssize_t inline_scan(indexObject *self, const char **offsets) |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1909 { |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
1910 const char *data = (const char *)self->buf.buf; |
20167
09e41ac6289d
mpatch: rewrite pointer overflow checks
Matt Mackall <mpm@selenic.com>
parents:
20109
diff
changeset
|
1911 Py_ssize_t pos = 0; |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
1912 Py_ssize_t end = self->buf.len; |
16863
bbedef66c6f3
parsers: replace magic number 64 with symbolic constant
Bryan O'Sullivan <bryano@fb.com>
parents:
16787
diff
changeset
|
1913 long incr = v1_hdrsize; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1914 Py_ssize_t len = 0; |
13254
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
11361
diff
changeset
|
1915 |
20167
09e41ac6289d
mpatch: rewrite pointer overflow checks
Matt Mackall <mpm@selenic.com>
parents:
20109
diff
changeset
|
1916 while (pos + v1_hdrsize <= end && pos >= 0) { |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1917 uint32_t comp_len; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1918 /* 3rd element of header is length of compressed inline data */ |
20167
09e41ac6289d
mpatch: rewrite pointer overflow checks
Matt Mackall <mpm@selenic.com>
parents:
20109
diff
changeset
|
1919 comp_len = getbe32(data + pos + 8); |
16863
bbedef66c6f3
parsers: replace magic number 64 with symbolic constant
Bryan O'Sullivan <bryano@fb.com>
parents:
16787
diff
changeset
|
1920 incr = v1_hdrsize + comp_len; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1921 if (offsets) |
20167
09e41ac6289d
mpatch: rewrite pointer overflow checks
Matt Mackall <mpm@selenic.com>
parents:
20109
diff
changeset
|
1922 offsets[len] = data + pos; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1923 len++; |
20167
09e41ac6289d
mpatch: rewrite pointer overflow checks
Matt Mackall <mpm@selenic.com>
parents:
20109
diff
changeset
|
1924 pos += incr; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1925 } |
13254
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
11361
diff
changeset
|
1926 |
20167
09e41ac6289d
mpatch: rewrite pointer overflow checks
Matt Mackall <mpm@selenic.com>
parents:
20109
diff
changeset
|
1927 if (pos != end) { |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1928 if (!PyErr_Occurred()) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1929 PyErr_SetString(PyExc_ValueError, "corrupt index file"); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1930 return -1; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1931 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1932 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1933 return len; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1934 } |
13254
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
11361
diff
changeset
|
1935 |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
1936 static int index_init(indexObject *self, PyObject *args) |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1937 { |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
1938 PyObject *data_obj, *inlined_obj; |
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
1939 Py_ssize_t size; |
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
1940 |
20109
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
1941 /* Initialize before argument-checking to avoid index_dealloc() crash. */ |
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
1942 self->raw_length = 0; |
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
1943 self->added = NULL; |
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
1944 self->cache = NULL; |
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
1945 self->data = NULL; |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
1946 memset(&self->buf, 0, sizeof(self->buf)); |
20109
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
1947 self->headrevs = NULL; |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
1948 self->filteredrevs = Py_None; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
1949 Py_INCREF(Py_None); |
20109
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
1950 self->nt = NULL; |
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
1951 self->offsets = NULL; |
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
1952 |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
1953 if (!PyArg_ParseTuple(args, "OO", &data_obj, &inlined_obj)) |
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
1954 return -1; |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
1955 if (!PyObject_CheckBuffer(data_obj)) { |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
1956 PyErr_SetString(PyExc_TypeError, |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
1957 "data does not support buffer interface"); |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
1958 return -1; |
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
1959 } |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
1960 |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
1961 if (PyObject_GetBuffer(data_obj, &self->buf, PyBUF_SIMPLE) == -1) |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
1962 return -1; |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
1963 size = self->buf.len; |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
1964 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1965 self->inlined = inlined_obj && PyObject_IsTrue(inlined_obj); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1966 self->data = data_obj; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1967 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1968 self->ntlookups = self->ntmisses = 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1969 self->ntrev = -1; |
16597
b767382a8675
parsers: fix refcount bug on corrupt index
Matt Mackall <mpm@selenic.com>
parents:
16572
diff
changeset
|
1970 Py_INCREF(self->data); |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
1971 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1972 if (self->inlined) { |
22401
9ba8a93e55f5
parsers: ensure correct return type for inline_scan
Henrik Stuart <hg@hstuart.dk>
parents:
22400
diff
changeset
|
1973 Py_ssize_t len = inline_scan(self, NULL); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1974 if (len == -1) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1975 goto bail; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1976 self->raw_length = len; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1977 self->length = len + 1; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1978 } else { |
16863
bbedef66c6f3
parsers: replace magic number 64 with symbolic constant
Bryan O'Sullivan <bryano@fb.com>
parents:
16787
diff
changeset
|
1979 if (size % v1_hdrsize) { |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1980 PyErr_SetString(PyExc_ValueError, "corrupt index file"); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1981 goto bail; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1982 } |
16863
bbedef66c6f3
parsers: replace magic number 64 with symbolic constant
Bryan O'Sullivan <bryano@fb.com>
parents:
16787
diff
changeset
|
1983 self->raw_length = size / v1_hdrsize; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1984 self->length = self->raw_length + 1; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1985 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1986 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1987 return 0; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1988 bail: |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1989 return -1; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1990 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
1991 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1992 static PyObject *index_nodemap(indexObject *self) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1993 { |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
1994 Py_INCREF(self); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1995 return (PyObject *)self; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1996 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1997 |
38944
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
1998 static void _index_clearcaches(indexObject *self) |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
1999 { |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2000 if (self->cache) { |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2001 Py_ssize_t i; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2002 |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2003 for (i = 0; i < self->raw_length; i++) |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2004 Py_CLEAR(self->cache[i]); |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2005 free(self->cache); |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2006 self->cache = NULL; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2007 } |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2008 if (self->offsets) { |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2009 PyMem_Free(self->offsets); |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2010 self->offsets = NULL; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2011 } |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2012 if (self->nt != NULL) { |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2013 free(self->nt->nodes); |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2014 PyMem_Free(self->nt); |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2015 } |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2016 self->nt = NULL; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2017 Py_CLEAR(self->headrevs); |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2018 } |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2019 |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2020 static PyObject *index_clearcaches(indexObject *self) |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2021 { |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2022 _index_clearcaches(self); |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2023 self->ntrev = -1; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2024 self->ntlookups = self->ntmisses = 0; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2025 Py_RETURN_NONE; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2026 } |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2027 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2028 static void index_dealloc(indexObject *self) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2029 { |
16370
28bb4daf070c
parsers: fix a memleak, and add a clearcaches method to the index
Bryan O'Sullivan <bryano@fb.com>
parents:
16363
diff
changeset
|
2030 _index_clearcaches(self); |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
2031 Py_XDECREF(self->filteredrevs); |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2032 if (self->buf.buf) { |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2033 PyBuffer_Release(&self->buf); |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2034 memset(&self->buf, 0, sizeof(self->buf)); |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2035 } |
20109
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
2036 Py_XDECREF(self->data); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2037 Py_XDECREF(self->added); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2038 PyObject_Del(self); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2039 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2040 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2041 static PySequenceMethods index_sequence_methods = { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2042 (lenfunc)index_length, /* sq_length */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2043 0, /* sq_concat */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2044 0, /* sq_repeat */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2045 (ssizeargfunc)index_get, /* sq_item */ |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2046 0, /* sq_slice */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2047 0, /* sq_ass_item */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2048 0, /* sq_ass_slice */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2049 (objobjproc)index_contains, /* sq_contains */ |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2050 }; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2051 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2052 static PyMappingMethods index_mapping_methods = { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2053 (lenfunc)index_length, /* mp_length */ |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2054 (binaryfunc)index_getitem, /* mp_subscript */ |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2055 (objobjargproc)index_assign_subscript, /* mp_ass_subscript */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2056 }; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2057 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2058 static PyMethodDef index_methods[] = { |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2059 {"ancestors", (PyCFunction)index_ancestors, METH_VARARGS, |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2060 "return the gca set of the given revs"}, |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2061 {"commonancestorsheads", (PyCFunction)index_commonancestorsheads, |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2062 METH_VARARGS, |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2063 "return the heads of the common ancestors of the given revs"}, |
16370
28bb4daf070c
parsers: fix a memleak, and add a clearcaches method to the index
Bryan O'Sullivan <bryano@fb.com>
parents:
16363
diff
changeset
|
2064 {"clearcaches", (PyCFunction)index_clearcaches, METH_NOARGS, |
28bb4daf070c
parsers: fix a memleak, and add a clearcaches method to the index
Bryan O'Sullivan <bryano@fb.com>
parents:
16363
diff
changeset
|
2065 "clear the index caches"}, |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2066 {"get", (PyCFunction)index_m_get, METH_VARARGS, |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2067 "get an index entry"}, |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
2068 {"computephasesmapsets", (PyCFunction)compute_phases_map_sets, |
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
2069 METH_VARARGS, "compute phases"}, |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
2070 {"reachableroots2", (PyCFunction)reachableroots2, METH_VARARGS, |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
2071 "reachableroots"}, |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
2072 {"headrevs", (PyCFunction)index_headrevs, METH_VARARGS, |
23087
42342f9afe01
parsers: introduce headrevsfiltered in C extension
Mads Kiilerich <madski@unity3d.com>
parents:
23073
diff
changeset
|
2073 "get head revisions"}, /* Can do filtering since 3.2 */ |
42342f9afe01
parsers: introduce headrevsfiltered in C extension
Mads Kiilerich <madski@unity3d.com>
parents:
23073
diff
changeset
|
2074 {"headrevsfiltered", (PyCFunction)index_headrevs, METH_VARARGS, |
42342f9afe01
parsers: introduce headrevsfiltered in C extension
Mads Kiilerich <madski@unity3d.com>
parents:
23073
diff
changeset
|
2075 "get filtered head revisions"}, /* Can always do filtering */ |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
2076 {"deltachain", (PyCFunction)index_deltachain, METH_VARARGS, |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
2077 "determine revisions with deltas to reconstruct fulltext"}, |
38850
6104b203bec8
index: replace insert(-1, e) method by append(e) method
Martin von Zweigbergk <martinvonz@google.com>
parents:
38848
diff
changeset
|
2078 {"append", (PyCFunction)index_append, METH_O, |
6104b203bec8
index: replace insert(-1, e) method by append(e) method
Martin von Zweigbergk <martinvonz@google.com>
parents:
38848
diff
changeset
|
2079 "append an index entry"}, |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2080 {"partialmatch", (PyCFunction)index_partialmatch, METH_VARARGS, |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2081 "match a potentially ambiguous node ID"}, |
37968
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2082 {"shortest", (PyCFunction)index_shortest, METH_VARARGS, |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2083 "find length of shortest hex nodeid of a binary ID"}, |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2084 {"stats", (PyCFunction)index_stats, METH_NOARGS, |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2085 "stats for the index"}, |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2086 {NULL} /* Sentinel */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2087 }; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2088 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2089 static PyGetSetDef index_getset[] = { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2090 {"nodemap", (getter)index_nodemap, NULL, "nodemap", NULL}, |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2091 {NULL} /* Sentinel */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2092 }; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2093 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2094 static PyTypeObject indexType = { |
34861
6ece4a85c350
cext: add /* header */ comment to all PyVarObject_HEAD_INIT() calls
Augie Fackler <augie@google.com>
parents:
34440
diff
changeset
|
2095 PyVarObject_HEAD_INIT(NULL, 0) /* header */ |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2096 "parsers.index", /* tp_name */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2097 sizeof(indexObject), /* tp_basicsize */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2098 0, /* tp_itemsize */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2099 (destructor)index_dealloc, /* tp_dealloc */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2100 0, /* tp_print */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2101 0, /* tp_getattr */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2102 0, /* tp_setattr */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2103 0, /* tp_compare */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2104 0, /* tp_repr */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2105 0, /* tp_as_number */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2106 &index_sequence_methods, /* tp_as_sequence */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2107 &index_mapping_methods, /* tp_as_mapping */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2108 0, /* tp_hash */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2109 0, /* tp_call */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2110 0, /* tp_str */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2111 0, /* tp_getattro */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2112 0, /* tp_setattro */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2113 0, /* tp_as_buffer */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2114 Py_TPFLAGS_DEFAULT, /* tp_flags */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2115 "revlog index", /* tp_doc */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2116 0, /* tp_traverse */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2117 0, /* tp_clear */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2118 0, /* tp_richcompare */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2119 0, /* tp_weaklistoffset */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2120 0, /* tp_iter */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2121 0, /* tp_iternext */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2122 index_methods, /* tp_methods */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2123 0, /* tp_members */ |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2124 index_getset, /* tp_getset */ |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2125 0, /* tp_base */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2126 0, /* tp_dict */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2127 0, /* tp_descr_get */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2128 0, /* tp_descr_set */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2129 0, /* tp_dictoffset */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2130 (initproc)index_init, /* tp_init */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2131 0, /* tp_alloc */ |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2132 }; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2133 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2134 /* |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2135 * returns a tuple of the form (index, index, cache) with elements as |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2136 * follows: |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2137 * |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2138 * index: an index object that lazily parses RevlogNG records |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2139 * cache: if data is inlined, a tuple (0, index_file_content), else None |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2140 * index_file_content could be a string, or a buffer |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2141 * |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2142 * added complications are for backwards compatibility |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2143 */ |
32378
7d0c69505a66
cext: extract revlog/index parsing code to own C file
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32372
diff
changeset
|
2144 PyObject *parse_index2(PyObject *self, PyObject *args) |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2145 { |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2146 PyObject *tuple = NULL, *cache = NULL; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2147 indexObject *idx; |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2148 int ret; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2149 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2150 idx = PyObject_New(indexObject, &indexType); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2151 if (idx == NULL) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2152 goto bail; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2153 |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2154 ret = index_init(idx, args); |
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2155 if (ret == -1) |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2156 goto bail; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2157 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2158 if (idx->inlined) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2159 cache = Py_BuildValue("iO", 0, idx->data); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2160 if (cache == NULL) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2161 goto bail; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2162 } else { |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2163 cache = Py_None; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2164 Py_INCREF(cache); |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2165 } |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2166 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2167 tuple = Py_BuildValue("NN", idx, cache); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2168 if (!tuple) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2169 goto bail; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2170 return tuple; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2171 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2172 bail: |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2173 Py_XDECREF(idx); |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2174 Py_XDECREF(cache); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2175 Py_XDECREF(tuple); |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2176 return NULL; |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2177 } |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2178 |
32378
7d0c69505a66
cext: extract revlog/index parsing code to own C file
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32372
diff
changeset
|
2179 void revlog_module_init(PyObject *mod) |
24017
72c9b5ae7278
parsers: add fm1readmarker
Augie Fackler <augie@google.com>
parents:
24004
diff
changeset
|
2180 { |
16604
48e42f984074
parsers: statically initializing tp_new to PyType_GenericNew is not portable
Adrian Buehlmann <adrian@cadifra.com>
parents:
16597
diff
changeset
|
2181 indexType.tp_new = PyType_GenericNew; |
32384
2e5a476b2e46
cext: move back finalization of dirstateTupleType where it should be
Yuya Nishihara <yuya@tcha.org>
parents:
32378
diff
changeset
|
2182 if (PyType_Ready(&indexType) < 0) |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2183 return; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2184 Py_INCREF(&indexType); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2185 PyModule_AddObject(mod, "index", (PyObject *)&indexType); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2186 |
36619
1f8c3fadbb8e
py3: bulk-replace bytes format specifier passed to Py_BuildValue()
Yuya Nishihara <yuya@tcha.org>
parents:
35309
diff
changeset
|
2187 nullentry = Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0, 0, |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2188 -1, -1, -1, -1, nullid, 20); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2189 if (nullentry) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2190 PyObject_GC_UnTrack(nullentry); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2191 } |