Mercurial > hg
annotate mercurial/cext/revlog.c @ 45131:61e7464477ac
phases: sparsify phaseroots and phasesets
As final step of dealing with the holes in the phase numbers, make
phaseroots and phasesets both dictionaries indexed by the phase number.
Further adjust the interface of the C module by pushing the node to
revision mapping down as it is cheaper on the C side to deal with
revision numbers.
Overall, the patch series improves a no-change "hg up" for my NetBSD test
repository from 4.7s to 1.3s.
Differential Revision: https://phab.mercurial-scm.org/D8698
author | Joerg Sonnenberger <joerg@bec.de> |
---|---|
date | Wed, 08 Jul 2020 00:36:36 +0200 |
parents | 090a1a78be4a |
children | 9719e118e4af |
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 |
42067
b01bbb8ff1f2
cext: make revlog.c PY_SSIZE_T_CLEAN
Gregory Szorc <gregory.szorc@gmail.com>
parents:
41283
diff
changeset
|
10 #define PY_SSIZE_T_CLEAN |
6389
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
11 #include <Python.h> |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
12 #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
|
13 #include <ctype.h> |
40704
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
14 #include <limits.h> |
17356
511dfb34b412
parsers: fix an integer size warning issued by clang
Bryan O'Sullivan <bryano@fb.com>
parents:
17353
diff
changeset
|
15 #include <stddef.h> |
40707
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
16 #include <stdlib.h> |
6389
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
17 #include <string.h> |
0231f763ebc8
manifest: improve parsing performance by 8x via a new C extension
Bryan O'Sullivan <bos@serpentine.com>
parents:
diff
changeset
|
18 |
34438
b90e8da190da
cext: reorder #include
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34437
diff
changeset
|
19 #include "bitmanipulation.h" |
33758
0f4ac3b6dee4
cext: factor out header for charencode.c
Yuya Nishihara <yuya@tcha.org>
parents:
33475
diff
changeset
|
20 #include "charencode.h" |
40859
aa76be85029b
revlog: export symbol of indexType
Yuya Nishihara <yuya@tcha.org>
parents:
40819
diff
changeset
|
21 #include "revlog.h" |
11361
3de3d670d2b6
parsers.c: Added support for py3k.
Renato Cunha <renatoc@gmail.com>
parents:
10449
diff
changeset
|
22 #include "util.h" |
3de3d670d2b6
parsers.c: Added support for py3k.
Renato Cunha <renatoc@gmail.com>
parents:
10449
diff
changeset
|
23 |
30112
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
24 #ifdef IS_PY3K |
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
25 /* 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
|
26 * 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
|
27 * 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
|
28 #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
|
29 #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
|
30 #define PyInt_FromSsize_t PyLong_FromSsize_t |
30112
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
31 #define PyInt_AsLong PyLong_AsLong |
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
32 #endif |
9b6ff0f940ed
parsers: move PyInt aliasing out of util.h
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30103
diff
changeset
|
33 |
38939
53bc73fae1a3
index: add pointer from nodetree back to index
Martin von Zweigbergk <martinvonz@google.com>
parents:
38938
diff
changeset
|
34 typedef struct indexObjectStruct indexObject; |
53bc73fae1a3
index: add pointer from nodetree back to index
Martin von Zweigbergk <martinvonz@google.com>
parents:
38938
diff
changeset
|
35 |
38912
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
36 typedef struct { |
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
37 int children[16]; |
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
38 } nodetreenode; |
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
39 |
43959
f384d68d8ea8
revlog: made C Capsule an array of function pointers
Georges Racinet <georges.racinet@octobus.net>
parents:
43847
diff
changeset
|
40 typedef struct { |
44066
f5d2720f3bea
revlog-native: introduced ABI version in capsule
Georges Racinet <georges.racinet@octobus.net>
parents:
43959
diff
changeset
|
41 int abi_version; |
44502
166349510398
revlog: using two new functions in C capsule from Rust code
Georges Racinet <georges.racinet@octobus.net>
parents:
44486
diff
changeset
|
42 Py_ssize_t (*index_length)(const indexObject *); |
166349510398
revlog: using two new functions in C capsule from Rust code
Georges Racinet <georges.racinet@octobus.net>
parents:
44486
diff
changeset
|
43 const char *(*index_node)(indexObject *, Py_ssize_t); |
43959
f384d68d8ea8
revlog: made C Capsule an array of function pointers
Georges Racinet <georges.racinet@octobus.net>
parents:
43847
diff
changeset
|
44 int (*index_parents)(PyObject *, int, int *); |
f384d68d8ea8
revlog: made C Capsule an array of function pointers
Georges Racinet <georges.racinet@octobus.net>
parents:
43847
diff
changeset
|
45 } Revlog_CAPI; |
f384d68d8ea8
revlog: made C Capsule an array of function pointers
Georges Racinet <georges.racinet@octobus.net>
parents:
43847
diff
changeset
|
46 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
47 /* |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
48 * 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
|
49 * |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
50 * 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
|
51 * 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
|
52 * Zero is empty |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
53 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
54 typedef struct { |
38939
53bc73fae1a3
index: add pointer from nodetree back to index
Martin von Zweigbergk <martinvonz@google.com>
parents:
38938
diff
changeset
|
55 indexObject *index; |
38912
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
56 nodetreenode *nodes; |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
57 unsigned length; /* # nodes in use */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
58 unsigned capacity; /* # nodes allocated */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
59 int depth; /* maximum depth of tree */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
60 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
|
61 } nodetree; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
62 |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
63 typedef struct { |
40560
8c1f36bf2d3e
revlog: add a comment to help clang-format produce less-awful results
Augie Fackler <augie@google.com>
parents:
40460
diff
changeset
|
64 PyObject_HEAD /* ; */ |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
65 nodetree nt; |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
66 } nodetreeObject; |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
67 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
68 /* |
26098 | 69 * 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
|
70 * |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
71 * When used in a list-like way (with integer keys), we decode an |
43582
ae5e39512ca0
revlog: delete references to deleted nullid sentinel value
Martin von Zweigbergk <martinvonz@google.com>
parents:
43554
diff
changeset
|
72 * entry in a RevlogNG index file on demand. We have limited support for |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
73 * integer-keyed insert and delete, only at elements right before the |
43582
ae5e39512ca0
revlog: delete references to deleted nullid sentinel value
Martin von Zweigbergk <martinvonz@google.com>
parents:
43554
diff
changeset
|
74 * end. |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
75 * |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
76 * 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
|
77 * 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
|
78 */ |
38939
53bc73fae1a3
index: add pointer from nodetree back to index
Martin von Zweigbergk <martinvonz@google.com>
parents:
38938
diff
changeset
|
79 struct indexObjectStruct { |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
80 PyObject_HEAD |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
81 /* Type-specific fields go here. */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
82 PyObject *data; /* raw bytes of index */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
83 Py_buffer buf; /* buffer of data */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
84 PyObject **cache; /* cached tuples */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
85 const char **offsets; /* populated on demand */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
86 Py_ssize_t raw_length; /* original number of elements */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
87 Py_ssize_t length; /* current number of elements */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
88 PyObject *added; /* populated on demand */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
89 PyObject *headrevs; /* cache, invalidated on changes */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
90 PyObject *filteredrevs; /* filtered revs set */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
91 nodetree nt; /* base-16 trie */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
92 int ntinitialized; /* 0 or 1 */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
93 int ntrev; /* last rev scanned */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
94 int ntlookups; /* # lookups */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
95 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
|
96 int inlined; |
38939
53bc73fae1a3
index: add pointer from nodetree back to index
Martin von Zweigbergk <martinvonz@google.com>
parents:
38938
diff
changeset
|
97 }; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
98 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
99 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
|
100 { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
101 if (self->added == NULL) |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
102 return self->length; |
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
103 return self->length + PyList_GET_SIZE(self->added); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
104 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
105 |
40099
994010b87534
revlog: explicitly initialize static variables
Yuya Nishihara <yuya@tcha.org>
parents:
40088
diff
changeset
|
106 static PyObject *nullentry = NULL; |
994010b87534
revlog: explicitly initialize static variables
Yuya Nishihara <yuya@tcha.org>
parents:
40088
diff
changeset
|
107 static const char nullid[20] = {0}; |
40960
43974cd44967
revlog: introduce a constant for nullrev in `revlog.c`
Boris Feld <boris.feld@octobus.net>
parents:
40862
diff
changeset
|
108 static const Py_ssize_t nullrev = -1; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
109 |
22401
9ba8a93e55f5
parsers: ensure correct return type for inline_scan
Henrik Stuart <hg@hstuart.dk>
parents:
22400
diff
changeset
|
110 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
|
111 |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
112 static int index_find_node(indexObject *self, const char *node, |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
113 Py_ssize_t nodelen); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
114 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
115 #if LONG_MAX == 0x7fffffffL |
36621
4015b9248da0
cext: mark tuple_format as a constant
Yuya Nishihara <yuya@tcha.org>
parents:
36620
diff
changeset
|
116 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
|
117 #else |
36621
4015b9248da0
cext: mark tuple_format as a constant
Yuya Nishihara <yuya@tcha.org>
parents:
36620
diff
changeset
|
118 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
|
119 #endif |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
120 |
16863
bbedef66c6f3
parsers: replace magic number 64 with symbolic constant
Bryan O'Sullivan <bryano@fb.com>
parents:
16787
diff
changeset
|
121 /* 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
|
122 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
|
123 |
39219
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
124 static void raise_revlog_error(void) |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
125 { |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
126 PyObject *mod = NULL, *dict = NULL, *errclass = NULL; |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
127 |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
128 mod = PyImport_ImportModule("mercurial.error"); |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
129 if (mod == NULL) { |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
130 goto cleanup; |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
131 } |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
132 |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
133 dict = PyModule_GetDict(mod); |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
134 if (dict == NULL) { |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
135 goto cleanup; |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
136 } |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
137 Py_INCREF(dict); |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
138 |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
139 errclass = PyDict_GetItemString(dict, "RevlogError"); |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
140 if (errclass == NULL) { |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
141 PyErr_SetString(PyExc_SystemError, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
142 "could not find RevlogError"); |
39219
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
143 goto cleanup; |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
144 } |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
145 |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
146 /* value of exception is ignored by callers */ |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
147 PyErr_SetString(errclass, "RevlogError"); |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
148 |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
149 cleanup: |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
150 Py_XDECREF(dict); |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
151 Py_XDECREF(mod); |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
152 } |
f85b25608252
index: move raise_revlog_error() further up
Martin von Zweigbergk <martinvonz@google.com>
parents:
39218
diff
changeset
|
153 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
154 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
155 * 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
|
156 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
157 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
|
158 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
159 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
|
160 if (self->offsets == NULL) { |
44580
3122058df7a5
cext: move variable declaration to the top of the block for C89 support
Matt Harbison <matt_harbison@yahoo.com>
parents:
44500
diff
changeset
|
161 Py_ssize_t ret; |
31470
bc445c556d3c
parsers: use Python memory allocator for indexObject->offsets
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31469
diff
changeset
|
162 self->offsets = PyMem_Malloc(self->raw_length * |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
163 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
|
164 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
|
165 return (const char *)PyErr_NoMemory(); |
44580
3122058df7a5
cext: move variable declaration to the top of the block for C89 support
Matt Harbison <matt_harbison@yahoo.com>
parents:
44500
diff
changeset
|
166 ret = inline_scan(self, self->offsets); |
44500
864e9534d3d4
cext-index: propagate inline_scan error in `index_deref`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44066
diff
changeset
|
167 if (ret == -1) { |
864e9534d3d4
cext-index: propagate inline_scan error in `index_deref`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44066
diff
changeset
|
168 return NULL; |
864e9534d3d4
cext-index: propagate inline_scan error in `index_deref`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44066
diff
changeset
|
169 }; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
170 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
171 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
|
172 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
173 |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
174 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
|
175 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
176 |
40812
9cdd525d97b2
revlog: fix out-of-bounds access by negative parents read from revlog (SEC)
Yuya Nishihara <yuya@tcha.org>
parents:
40454
diff
changeset
|
177 /* |
9cdd525d97b2
revlog: fix out-of-bounds access by negative parents read from revlog (SEC)
Yuya Nishihara <yuya@tcha.org>
parents:
40454
diff
changeset
|
178 * Get parents of the given rev. |
9cdd525d97b2
revlog: fix out-of-bounds access by negative parents read from revlog (SEC)
Yuya Nishihara <yuya@tcha.org>
parents:
40454
diff
changeset
|
179 * |
9cdd525d97b2
revlog: fix out-of-bounds access by negative parents read from revlog (SEC)
Yuya Nishihara <yuya@tcha.org>
parents:
40454
diff
changeset
|
180 * The specified rev must be valid and must not be nullrev. A returned |
9cdd525d97b2
revlog: fix out-of-bounds access by negative parents read from revlog (SEC)
Yuya Nishihara <yuya@tcha.org>
parents:
40454
diff
changeset
|
181 * parent revision may be nullrev, but is guaranteed to be in valid range. |
9cdd525d97b2
revlog: fix out-of-bounds access by negative parents read from revlog (SEC)
Yuya Nishihara <yuya@tcha.org>
parents:
40454
diff
changeset
|
182 */ |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
183 static inline int index_get_parents(indexObject *self, Py_ssize_t rev, int *ps, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
184 int maxrev) |
25311
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
185 { |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
186 if (rev >= self->length) { |
40598
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
187 long tmp; |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
188 PyObject *tuple = |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
189 PyList_GET_ITEM(self->added, rev - self->length); |
40598
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
190 if (!pylong_to_long(PyTuple_GET_ITEM(tuple, 5), &tmp)) { |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
191 return -1; |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
192 } |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
193 ps[0] = (int)tmp; |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
194 if (!pylong_to_long(PyTuple_GET_ITEM(tuple, 6), &tmp)) { |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
195 return -1; |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
196 } |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
197 ps[1] = (int)tmp; |
25311
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
198 } else { |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
199 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
|
200 ps[0] = getbe32(data + 24); |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
201 ps[1] = getbe32(data + 28); |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
202 } |
25810
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
203 /* 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
|
204 * there is a risk of buffer overflow to trust them unconditionally. */ |
40812
9cdd525d97b2
revlog: fix out-of-bounds access by negative parents read from revlog (SEC)
Yuya Nishihara <yuya@tcha.org>
parents:
40454
diff
changeset
|
205 if (ps[0] < -1 || ps[0] > maxrev || ps[1] < -1 || ps[1] > maxrev) { |
25810
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
206 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
|
207 return -1; |
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
208 } |
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
209 return 0; |
25311
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
210 } |
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
211 |
40861
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
212 /* |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
213 * Get parents of the given rev. |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
214 * |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
215 * If the specified rev is out of range, IndexError will be raised. If the |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
216 * revlog entry is corrupted, ValueError may be raised. |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
217 * |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
218 * Returns 0 on success or -1 on failure. |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
219 */ |
44467
9db11679f8ac
cext: make HgRevlogIndex_GetParents private again
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44066
diff
changeset
|
220 static int HgRevlogIndex_GetParents(PyObject *op, int rev, int *ps) |
40861
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
221 { |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
222 int tiprev; |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
223 if (!op || !HgRevlogIndex_Check(op) || !ps) { |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
224 PyErr_BadInternalCall(); |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
225 return -1; |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
226 } |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
227 tiprev = (int)index_length((indexObject *)op) - 1; |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
228 if (rev < -1 || rev > tiprev) { |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
229 PyErr_Format(PyExc_IndexError, "rev out of range: %d", rev); |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
230 return -1; |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
231 } else if (rev == -1) { |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
232 ps[0] = ps[1] = -1; |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
233 return 0; |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
234 } else { |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
235 return index_get_parents((indexObject *)op, rev, ps, tiprev); |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
236 } |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
237 } |
b12700dd261f
revlog: add public CPython function to get parent revisions
Yuya Nishihara <yuya@tcha.org>
parents:
40860
diff
changeset
|
238 |
40703
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
239 static inline int64_t index_get_start(indexObject *self, Py_ssize_t rev) |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
240 { |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
241 uint64_t offset; |
40961
b54727f82511
sparse-revlog: handle nullrev in index_get_start
Boris Feld <boris.feld@octobus.net>
parents:
40960
diff
changeset
|
242 if (rev == nullrev) { |
b54727f82511
sparse-revlog: handle nullrev in index_get_start
Boris Feld <boris.feld@octobus.net>
parents:
40960
diff
changeset
|
243 return 0; |
b54727f82511
sparse-revlog: handle nullrev in index_get_start
Boris Feld <boris.feld@octobus.net>
parents:
40960
diff
changeset
|
244 } |
40703
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
245 if (rev >= self->length) { |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
246 PyObject *tuple; |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
247 PyObject *pylong; |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
248 PY_LONG_LONG tmp; |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
249 tuple = PyList_GET_ITEM(self->added, rev - self->length); |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
250 pylong = PyTuple_GET_ITEM(tuple, 0); |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
251 tmp = PyLong_AsLongLong(pylong); |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
252 if (tmp == -1 && PyErr_Occurred()) { |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
253 return -1; |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
254 } |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
255 if (tmp < 0) { |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
256 PyErr_Format(PyExc_OverflowError, |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
257 "revlog entry size out of bound (%lld)", |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
258 (long long)tmp); |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
259 return -1; |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
260 } |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
261 offset = (uint64_t)tmp; |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
262 } else { |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
263 const char *data = index_deref(self, rev); |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
264 offset = getbe32(data + 4); |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
265 if (rev == 0) { |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
266 /* mask out version number for the first entry */ |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
267 offset &= 0xFFFF; |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
268 } else { |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
269 uint32_t offset_high = getbe32(data); |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
270 offset |= ((uint64_t)offset_high) << 32; |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
271 } |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
272 } |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
273 return (int64_t)(offset >> 16); |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
274 } |
d5b300ec2e89
sparse-revlog: add a `index_get_start` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40598
diff
changeset
|
275 |
40704
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
276 static inline int index_get_length(indexObject *self, Py_ssize_t rev) |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
277 { |
40962
c6939b353ebd
sparse-revlog: handle nullrev in index_get_length
Boris Feld <boris.feld@octobus.net>
parents:
40961
diff
changeset
|
278 if (rev == nullrev) { |
c6939b353ebd
sparse-revlog: handle nullrev in index_get_length
Boris Feld <boris.feld@octobus.net>
parents:
40961
diff
changeset
|
279 return 0; |
c6939b353ebd
sparse-revlog: handle nullrev in index_get_length
Boris Feld <boris.feld@octobus.net>
parents:
40961
diff
changeset
|
280 } |
40704
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
281 if (rev >= self->length) { |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
282 PyObject *tuple; |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
283 PyObject *pylong; |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
284 long ret; |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
285 tuple = PyList_GET_ITEM(self->added, rev - self->length); |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
286 pylong = PyTuple_GET_ITEM(tuple, 1); |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
287 ret = PyInt_AsLong(pylong); |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
288 if (ret == -1 && PyErr_Occurred()) { |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
289 return -1; |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
290 } |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
291 if (ret < 0 || ret > (long)INT_MAX) { |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
292 PyErr_Format(PyExc_OverflowError, |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
293 "revlog entry size out of bound (%ld)", |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
294 ret); |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
295 return -1; |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
296 } |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
297 return (int)ret; |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
298 } else { |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
299 const char *data = index_deref(self, rev); |
40741
959130631de3
revlog: properly detect corrupted revlog in `index_get_length`
Boris Feld <boris.feld@octobus.net>
parents:
40707
diff
changeset
|
300 int tmp = (int)getbe32(data + 8); |
959130631de3
revlog: properly detect corrupted revlog in `index_get_length`
Boris Feld <boris.feld@octobus.net>
parents:
40707
diff
changeset
|
301 if (tmp < 0) { |
959130631de3
revlog: properly detect corrupted revlog in `index_get_length`
Boris Feld <boris.feld@octobus.net>
parents:
40707
diff
changeset
|
302 PyErr_Format(PyExc_OverflowError, |
959130631de3
revlog: properly detect corrupted revlog in `index_get_length`
Boris Feld <boris.feld@octobus.net>
parents:
40707
diff
changeset
|
303 "revlog entry size out of bound (%d)", |
959130631de3
revlog: properly detect corrupted revlog in `index_get_length`
Boris Feld <boris.feld@octobus.net>
parents:
40707
diff
changeset
|
304 tmp); |
959130631de3
revlog: properly detect corrupted revlog in `index_get_length`
Boris Feld <boris.feld@octobus.net>
parents:
40707
diff
changeset
|
305 return -1; |
959130631de3
revlog: properly detect corrupted revlog in `index_get_length`
Boris Feld <boris.feld@octobus.net>
parents:
40707
diff
changeset
|
306 } |
959130631de3
revlog: properly detect corrupted revlog in `index_get_length`
Boris Feld <boris.feld@octobus.net>
parents:
40707
diff
changeset
|
307 return tmp; |
40704
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
308 } |
7da3729d4b45
sparse-revlog: add a `index_get_length` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40703
diff
changeset
|
309 } |
25311
d2e88f960d1a
parsers: move index_get_parents's declaration higher
Laurent Charignon <lcharignon@fb.com>
parents:
25297
diff
changeset
|
310 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
311 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
312 * 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
|
313 * 6 bytes: offset |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
314 * 2 bytes: flags |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
315 * 4 bytes: compressed length |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
316 * 4 bytes: uncompressed length |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
317 * 4 bytes: base revision |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
318 * 4 bytes: link revision |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
319 * 4 bytes: parent 1 revision |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
320 * 4 bytes: parent 2 revision |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
321 * 32 bytes: nodeid (only 20 bytes used) |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
322 */ |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
323 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
|
324 { |
7154
7fdf7a0a41b7
index parser: fix refcounting in case of errors, refactor
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7135
diff
changeset
|
325 uint64_t offset_flags; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
326 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
|
327 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
|
328 const char *data; |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
329 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
|
330 PyObject *entry; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
331 |
40960
43974cd44967
revlog: introduce a constant for nullrev in `revlog.c`
Boris Feld <boris.feld@octobus.net>
parents:
40862
diff
changeset
|
332 if (pos == nullrev) { |
38847
f3d394ea17db
index: handle index[-1] as nullid more explicitly
Martin von Zweigbergk <martinvonz@google.com>
parents:
38846
diff
changeset
|
333 Py_INCREF(nullentry); |
f3d394ea17db
index: handle index[-1] as nullid more explicitly
Martin von Zweigbergk <martinvonz@google.com>
parents:
38846
diff
changeset
|
334 return nullentry; |
f3d394ea17db
index: handle index[-1] as nullid more explicitly
Martin von Zweigbergk <martinvonz@google.com>
parents:
38846
diff
changeset
|
335 } |
f3d394ea17db
index: handle index[-1] as nullid more explicitly
Martin von Zweigbergk <martinvonz@google.com>
parents:
38846
diff
changeset
|
336 |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
337 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
|
338 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
|
339 return NULL; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
340 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
341 |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
342 if (pos >= self->length) { |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
343 PyObject *obj; |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
344 obj = PyList_GET_ITEM(self->added, pos - self->length); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
345 Py_INCREF(obj); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
346 return obj; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
347 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
348 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
349 if (self->cache) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
350 if (self->cache[pos]) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
351 Py_INCREF(self->cache[pos]); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
352 return self->cache[pos]; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
353 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
354 } else { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
355 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
|
356 if (self->cache == NULL) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
357 return PyErr_NoMemory(); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
358 } |
7190
aecea6934fdd
Some additional space/tab cleanups
Thomas Arendsen Hein <thomas@intevation.de>
parents:
7186
diff
changeset
|
359 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
360 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
|
361 if (data == NULL) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
362 return NULL; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
363 |
16437
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
364 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
|
365 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
|
366 offset_flags &= 0xFFFF; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
367 else { |
16437
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
368 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
|
369 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
|
370 } |
7154
7fdf7a0a41b7
index parser: fix refcounting in case of errors, refactor
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7135
diff
changeset
|
371 |
16437
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
372 comp_len = getbe32(data + 8); |
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
373 uncomp_len = getbe32(data + 12); |
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
374 base_rev = getbe32(data + 16); |
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
375 link_rev = getbe32(data + 20); |
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
376 parent_1 = getbe32(data + 24); |
d126a0d16856
util.h: replace ntohl/htonl with get/putbe32
Matt Mackall <mpm@selenic.com>
parents:
16414
diff
changeset
|
377 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
|
378 c_node_id = data + 32; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
379 |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
380 entry = Py_BuildValue(tuple_format, offset_flags, comp_len, uncomp_len, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
381 base_rev, link_rev, parent_1, parent_2, c_node_id, |
42096
509a0477b3a6
cext: cast s# arguments of Py_BuildValue() to Py_ssize_t
Yuya Nishihara <yuya@tcha.org>
parents:
42067
diff
changeset
|
382 (Py_ssize_t)20); |
13254
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
11361
diff
changeset
|
383 |
19726
b3c8c6f2b5c1
parsers: use Py_INCREF safely
Bryan O'Sullivan <bryano@fb.com>
parents:
19725
diff
changeset
|
384 if (entry) { |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
385 PyObject_GC_UnTrack(entry); |
19726
b3c8c6f2b5c1
parsers: use Py_INCREF safely
Bryan O'Sullivan <bryano@fb.com>
parents:
19725
diff
changeset
|
386 Py_INCREF(entry); |
b3c8c6f2b5c1
parsers: use Py_INCREF safely
Bryan O'Sullivan <bryano@fb.com>
parents:
19725
diff
changeset
|
387 } |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
388 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
389 self->cache[pos] = entry; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
390 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
391 return entry; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
392 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
393 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
394 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
395 * 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
|
396 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
397 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
|
398 { |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
399 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
|
400 const char *data; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
401 |
40960
43974cd44967
revlog: introduce a constant for nullrev in `revlog.c`
Boris Feld <boris.feld@octobus.net>
parents:
40862
diff
changeset
|
402 if (pos == nullrev) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
403 return nullid; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
404 |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
405 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
|
406 return NULL; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
407 |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
408 if (pos >= self->length) { |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
409 PyObject *tuple, *str; |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
410 tuple = PyList_GET_ITEM(self->added, pos - self->length); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
411 str = PyTuple_GetItem(tuple, 7); |
30100
c5afe5531709
parsers: convert PyString* to PyBytes*
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30090
diff
changeset
|
412 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
|
413 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
414 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
415 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
|
416 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
|
417 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
418 |
37860
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
419 /* |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
420 * 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
|
421 * 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
|
422 */ |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
423 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
|
424 { |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
425 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
|
426 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
|
427 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
|
428 (int)pos); |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
429 } |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
430 return node; |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
431 } |
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
432 |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
433 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
|
434 |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
435 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
|
436 { |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
437 Py_ssize_t nodelen; |
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
438 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
|
439 return -1; |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
440 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
|
441 return 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
442 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
|
443 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
444 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
445 |
38850
6104b203bec8
index: replace insert(-1, e) method by append(e) method
Martin von Zweigbergk <martinvonz@google.com>
parents:
38848
diff
changeset
|
446 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
|
447 { |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
448 char *node; |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
449 Py_ssize_t len; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
450 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
451 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
|
452 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
|
453 return NULL; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
454 } |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
455 |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
456 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
|
457 return NULL; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
458 |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
459 len = index_length(self); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
460 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
461 if (self->added == NULL) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
462 self->added = PyList_New(0); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
463 if (self->added == NULL) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
464 return NULL; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
465 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
466 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
467 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
|
468 return NULL; |
13254
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
11361
diff
changeset
|
469 |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
470 if (self->ntinitialized) |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
471 nt_insert(&self->nt, node, (int)len); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
472 |
16787
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
473 Py_CLEAR(self->headrevs); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
474 Py_RETURN_NONE; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
475 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
476 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
477 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
|
478 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
479 PyObject *obj = PyDict_New(); |
40455
88702fd208ce
py3: convert revlog stats to a dict of (bytes, int) pairs
Yuya Nishihara <yuya@tcha.org>
parents:
40300
diff
changeset
|
480 PyObject *s = NULL; |
23948
bd307b462ce2
parsers: avoid leaking several PyObjects in index_stats
Augie Fackler <augie@google.com>
parents:
23947
diff
changeset
|
481 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
|
482 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
483 if (obj == NULL) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
484 return NULL; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
485 |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
486 #define istat(__n, __d) \ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
487 do { \ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
488 s = PyBytes_FromString(__d); \ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
489 t = PyInt_FromSsize_t(self->__n); \ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
490 if (!s || !t) \ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
491 goto bail; \ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
492 if (PyDict_SetItem(obj, s, t) == -1) \ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
493 goto bail; \ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
494 Py_CLEAR(s); \ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
495 Py_CLEAR(t); \ |
28792
507136150d2b
parsers: fix istat macro to work with single line if statement
Matt Fowles <matt.fowles@gmail.com>
parents:
28386
diff
changeset
|
496 } while (0) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
497 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
498 if (self->added) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
499 Py_ssize_t len = PyList_GET_SIZE(self->added); |
40455
88702fd208ce
py3: convert revlog stats to a dict of (bytes, int) pairs
Yuya Nishihara <yuya@tcha.org>
parents:
40300
diff
changeset
|
500 s = PyBytes_FromString("index entries added"); |
23948
bd307b462ce2
parsers: avoid leaking several PyObjects in index_stats
Augie Fackler <augie@google.com>
parents:
23947
diff
changeset
|
501 t = PyInt_FromSsize_t(len); |
40455
88702fd208ce
py3: convert revlog stats to a dict of (bytes, int) pairs
Yuya Nishihara <yuya@tcha.org>
parents:
40300
diff
changeset
|
502 if (!s || !t) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
503 goto bail; |
40455
88702fd208ce
py3: convert revlog stats to a dict of (bytes, int) pairs
Yuya Nishihara <yuya@tcha.org>
parents:
40300
diff
changeset
|
504 if (PyDict_SetItem(obj, s, t) == -1) |
23948
bd307b462ce2
parsers: avoid leaking several PyObjects in index_stats
Augie Fackler <augie@google.com>
parents:
23947
diff
changeset
|
505 goto bail; |
40455
88702fd208ce
py3: convert revlog stats to a dict of (bytes, int) pairs
Yuya Nishihara <yuya@tcha.org>
parents:
40300
diff
changeset
|
506 Py_CLEAR(s); |
88702fd208ce
py3: convert revlog stats to a dict of (bytes, int) pairs
Yuya Nishihara <yuya@tcha.org>
parents:
40300
diff
changeset
|
507 Py_CLEAR(t); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
508 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
509 |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
510 if (self->raw_length != self->length) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
511 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
|
512 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
|
513 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
|
514 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
|
515 istat(ntrev, "node trie last rev scanned"); |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
516 if (self->ntinitialized) { |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
517 istat(nt.capacity, "node trie capacity"); |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
518 istat(nt.depth, "node trie depth"); |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
519 istat(nt.length, "node trie count"); |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
520 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
|
521 } |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
522 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
523 #undef istat |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
524 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
525 return obj; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
526 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
527 bail: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
528 Py_XDECREF(obj); |
40455
88702fd208ce
py3: convert revlog stats to a dict of (bytes, int) pairs
Yuya Nishihara <yuya@tcha.org>
parents:
40300
diff
changeset
|
529 Py_XDECREF(s); |
23948
bd307b462ce2
parsers: avoid leaking several PyObjects in index_stats
Augie Fackler <augie@google.com>
parents:
23947
diff
changeset
|
530 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
|
531 return NULL; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
532 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
533 |
16787
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
534 /* |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
535 * 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
|
536 * the cached copy. |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
537 */ |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
538 static PyObject *list_copy(PyObject *list) |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
539 { |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
540 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
|
541 PyObject *newlist = PyList_New(len); |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
542 Py_ssize_t i; |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
543 |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
544 if (newlist == NULL) |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
545 return NULL; |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
546 |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
547 for (i = 0; i < len; i++) { |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
548 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
|
549 Py_INCREF(obj); |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
550 PyList_SET_ITEM(newlist, i, obj); |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
551 } |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
552 |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
553 return newlist; |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
554 } |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
555 |
34440
7ed0750c71a1
cext: wrap before brace for functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34438
diff
changeset
|
556 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
|
557 { |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
558 if (filter) { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
559 PyObject *arglist, *result; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
560 int isfiltered; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
561 |
26107
50582df9d7a7
parsers: fix two cases of unsigned long instead of Py_ssize_t
Augie Fackler <augie@google.com>
parents:
26098
diff
changeset
|
562 arglist = Py_BuildValue("(n)", arg); |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
563 if (!arglist) { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
564 return -1; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
565 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
566 |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
567 result = PyEval_CallObject(filter, arglist); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
568 Py_DECREF(arglist); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
569 if (!result) { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
570 return -1; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
571 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
572 |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
573 /* 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
|
574 * 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
|
575 isfiltered = PyObject_IsTrue(result); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
576 Py_DECREF(result); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
577 return isfiltered; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
578 } else { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
579 return 0; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
580 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
581 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
582 |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
583 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
|
584 int parent_2, Py_ssize_t i) |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
585 { |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
586 if (parent_1 >= 0 && phases[parent_1] > phases[i]) |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
587 phases[i] = phases[parent_1]; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
588 if (parent_2 >= 0 && phases[parent_2] > phases[i]) |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
589 phases[i] = phases[parent_2]; |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
590 } |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
591 |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
592 static PyObject *reachableroots2(indexObject *self, PyObject *args) |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
593 { |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
594 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
595 /* Input */ |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
596 long minroot; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
597 PyObject *includepatharg = NULL; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
598 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
|
599 /* heads and roots are lists */ |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
600 PyObject *heads = NULL; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
601 PyObject *roots = NULL; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
602 PyObject *reachable = NULL; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
603 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
604 PyObject *val; |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
605 Py_ssize_t len = index_length(self); |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
606 long revnum; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
607 Py_ssize_t k; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
608 Py_ssize_t i; |
26042
2a3010ba6f52
reachableroots: give anonymous name to short-lived "numheads" variable
Yuya Nishihara <yuya@tcha.org>
parents:
26041
diff
changeset
|
609 Py_ssize_t l; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
610 int r; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
611 int parents[2]; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
612 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
613 /* Internal data structure: |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
614 * tovisit: array of length len+1 (all revs + nullrev), filled upto |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
615 * lentovisit |
40561
5c14bf0c5be3
revlog: add blank line in comment to help clang-format
Augie Fackler <augie@google.com>
parents:
40560
diff
changeset
|
616 * |
26044
b3ad349d0e50
reachableroots: extend "revstates" to array of bit flags
Yuya Nishihara <yuya@tcha.org>
parents:
26043
diff
changeset
|
617 * 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
|
618 int *tovisit = NULL; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
619 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
|
620 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
|
621 char *revstates = NULL; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
622 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
623 /* Get arguments */ |
26009
bbb698697efc
reachableroots: fix transposition of set and list types in PyArg_ParseTuple
Augie Fackler <augie@google.com>
parents:
26008
diff
changeset
|
624 if (!PyArg_ParseTuple(args, "lO!O!O!", &minroot, &PyList_Type, &heads, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
625 &PyList_Type, &roots, &PyBool_Type, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
626 &includepatharg)) |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
627 goto bail; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
628 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
629 if (includepatharg == Py_True) |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
630 includepath = 1; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
631 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
632 /* Initialize return set */ |
26055
607868eccaa7
reachableroots: return list of revisions instead of set
Yuya Nishihara <yuya@tcha.org>
parents:
26054
diff
changeset
|
633 reachable = PyList_New(0); |
607868eccaa7
reachableroots: return list of revisions instead of set
Yuya Nishihara <yuya@tcha.org>
parents:
26054
diff
changeset
|
634 if (reachable == NULL) |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
635 goto bail; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
636 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
637 /* Initialize internal datastructures */ |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
638 tovisit = (int *)malloc((len + 1) * sizeof(int)); |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
639 if (tovisit == NULL) { |
26008
59d57ea69ae6
reachableroots: consistently use short-form of PyErr_NoMemory()
Augie Fackler <augie@google.com>
parents:
26007
diff
changeset
|
640 PyErr_NoMemory(); |
26016
c8d41c9c23c7
reachableroots: unify bail cases to raise exception correctly
Yuya Nishihara <yuya@tcha.org>
parents:
26015
diff
changeset
|
641 goto bail; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
642 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
643 |
26043
f2f0a3ab6e41
reachableroots: rename "seen" array to "revstates" for future extension
Yuya Nishihara <yuya@tcha.org>
parents:
26042
diff
changeset
|
644 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
|
645 if (revstates == NULL) { |
26008
59d57ea69ae6
reachableroots: consistently use short-form of PyErr_NoMemory()
Augie Fackler <augie@google.com>
parents:
26007
diff
changeset
|
646 PyErr_NoMemory(); |
26016
c8d41c9c23c7
reachableroots: unify bail cases to raise exception correctly
Yuya Nishihara <yuya@tcha.org>
parents:
26015
diff
changeset
|
647 goto bail; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
648 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
649 |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
650 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
|
651 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
|
652 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
|
653 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
|
654 goto bail; |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
655 /* 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
|
656 * 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
|
657 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
|
658 continue; |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
659 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
|
660 } |
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26052
diff
changeset
|
661 |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
662 /* 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
|
663 l = PyList_GET_SIZE(heads); |
2a3010ba6f52
reachableroots: give anonymous name to short-lived "numheads" variable
Yuya Nishihara <yuya@tcha.org>
parents:
26041
diff
changeset
|
664 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
|
665 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
|
666 if (revnum == -1 && PyErr_Occurred()) |
c6115c30a376
reachableroots: verify type of each item of heads argument
Yuya Nishihara <yuya@tcha.org>
parents:
26017
diff
changeset
|
667 goto bail; |
26017
44705659da94
reachableroots: verify integer range of heads argument (issue4775)
Yuya Nishihara <yuya@tcha.org>
parents:
26016
diff
changeset
|
668 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
|
669 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
|
670 goto bail; |
44705659da94
reachableroots: verify integer range of heads argument (issue4775)
Yuya Nishihara <yuya@tcha.org>
parents:
26016
diff
changeset
|
671 } |
26044
b3ad349d0e50
reachableroots: extend "revstates" to array of bit flags
Yuya Nishihara <yuya@tcha.org>
parents:
26043
diff
changeset
|
672 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
|
673 tovisit[lentovisit++] = (int)revnum; |
26044
b3ad349d0e50
reachableroots: extend "revstates" to array of bit flags
Yuya Nishihara <yuya@tcha.org>
parents:
26043
diff
changeset
|
674 revstates[revnum + 1] |= RS_SEEN; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
675 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
676 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
677 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
678 /* Visit the tovisit list and find the reachable roots */ |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
679 k = 0; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
680 while (k < lentovisit) { |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
681 /* 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
|
682 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
|
683 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
|
684 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
|
685 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
|
686 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
|
687 goto bail; |
26058
e7fe0a12376c
reachableroots: handle error of PyList_Append()
Yuya Nishihara <yuya@tcha.org>
parents:
26055
diff
changeset
|
688 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
|
689 Py_DECREF(val); |
26058
e7fe0a12376c
reachableroots: handle error of PyList_Append()
Yuya Nishihara <yuya@tcha.org>
parents:
26055
diff
changeset
|
690 if (r < 0) |
e7fe0a12376c
reachableroots: handle error of PyList_Append()
Yuya Nishihara <yuya@tcha.org>
parents:
26055
diff
changeset
|
691 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
|
692 if (includepath == 0) |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
693 continue; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
694 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
695 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
696 /* Add its parents to the list of nodes to visit */ |
40960
43974cd44967
revlog: introduce a constant for nullrev in `revlog.c`
Boris Feld <boris.feld@octobus.net>
parents:
40862
diff
changeset
|
697 if (revnum == nullrev) |
26041
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
698 continue; |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
699 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
|
700 if (r < 0) |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
701 goto bail; |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
702 for (i = 0; i < 2; i++) { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
703 if (!(revstates[parents[i] + 1] & RS_SEEN) && |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
704 parents[i] >= minroot) { |
26041
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
705 tovisit[lentovisit++] = parents[i]; |
26044
b3ad349d0e50
reachableroots: extend "revstates" to array of bit flags
Yuya Nishihara <yuya@tcha.org>
parents:
26043
diff
changeset
|
706 revstates[parents[i] + 1] |= RS_SEEN; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
707 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
708 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
709 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
710 |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
711 /* 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
|
712 * and add them to the reachable set */ |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
713 if (includepath == 1) { |
26080
83c9edcac05c
reachableroots: silence warning of implicit integer narrowing issued by clang
Yuya Nishihara <yuya@tcha.org>
parents:
26079
diff
changeset
|
714 long minidx = minroot; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
715 if (minidx < 0) |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
716 minidx = 0; |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
717 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
|
718 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
|
719 continue; |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
720 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
|
721 /* 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
|
722 * index_get_parents */ |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
723 if (r < 0) |
8da628be211b
reachableroots: reduce nesting level by jumping to next iteration by continue
Yuya Nishihara <yuya@tcha.org>
parents:
26033
diff
changeset
|
724 goto bail; |
26059
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
725 if (((revstates[parents[0] + 1] | |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
726 revstates[parents[1] + 1]) & |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
727 RS_REACHABLE) && |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
728 !(revstates[i + 1] & RS_REACHABLE)) { |
26059
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
729 revstates[i + 1] |= RS_REACHABLE; |
39074
acd23830bcd6
cext: fix most truncation warnings in revlog on Windows
Matt Harbison <matt_harbison@yahoo.com>
parents:
39073
diff
changeset
|
730 val = PyInt_FromSsize_t(i); |
26059
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
731 if (val == NULL) |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
732 goto bail; |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
733 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
|
734 Py_DECREF(val); |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
735 if (r < 0) |
8779ce81ea80
reachableroots: unroll loop that checks if one of parents is reachable
Yuya Nishihara <yuya@tcha.org>
parents:
26058
diff
changeset
|
736 goto bail; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
737 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
738 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
739 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
740 |
26043
f2f0a3ab6e41
reachableroots: rename "seen" array to "revstates" for future extension
Yuya Nishihara <yuya@tcha.org>
parents:
26042
diff
changeset
|
741 free(revstates); |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
742 free(tovisit); |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
743 return reachable; |
26016
c8d41c9c23c7
reachableroots: unify bail cases to raise exception correctly
Yuya Nishihara <yuya@tcha.org>
parents:
26015
diff
changeset
|
744 bail: |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
745 Py_XDECREF(reachable); |
26043
f2f0a3ab6e41
reachableroots: rename "seen" array to "revstates" for future extension
Yuya Nishihara <yuya@tcha.org>
parents:
26042
diff
changeset
|
746 free(revstates); |
26016
c8d41c9c23c7
reachableroots: unify bail cases to raise exception correctly
Yuya Nishihara <yuya@tcha.org>
parents:
26015
diff
changeset
|
747 free(tovisit); |
26010
2c03e521a0c5
reachableroots: return NULL if we're throwing an exception
Augie Fackler <augie@google.com>
parents:
26009
diff
changeset
|
748 return NULL; |
26004
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
749 } |
ff89383a97db
reachableroots: add a C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
25911
diff
changeset
|
750 |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
751 static int add_roots_get_min(indexObject *self, PyObject *roots, char *phases, |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
752 char phase) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
753 { |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
754 Py_ssize_t len = index_length(self); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
755 PyObject *iter; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
756 PyObject *item; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
757 PyObject *iterator; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
758 int rev, minrev = -1; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
759 char *node; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
760 |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
761 if (!PySet_Check(roots)) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
762 return -2; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
763 iterator = PyObject_GetIter(roots); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
764 if (iterator == NULL) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
765 return -2; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
766 while ((item = PyIter_Next(iterator))) { |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
767 if (node_check(item, &node) == -1) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
768 goto failed; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
769 rev = index_find_node(self, node, 20); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
770 /* null is implicitly public, so negative is invalid */ |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
771 if (rev < 0 || rev >= len) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
772 goto failed; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
773 phases[rev] = phase; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
774 if (minrev == -1 || minrev > rev) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
775 minrev = rev; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
776 Py_DECREF(item); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
777 } |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
778 Py_DECREF(iterator); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
779 return minrev; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
780 failed: |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
781 Py_DECREF(iterator); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
782 Py_DECREF(item); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
783 return -2; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
784 } |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
785 |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
786 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
|
787 { |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
788 /* 0: public (untracked), 1: draft, 2: secret, 32: archive, |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
789 96: internal */ |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
790 static const char trackedphases[] = {1, 2, 32, 96}; |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
791 PyObject *ret = NULL; |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
792 PyObject *roots = Py_None; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
793 PyObject *idx = NULL; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
794 PyObject *pyphase = NULL; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
795 PyObject *pyrev = NULL; |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
796 PyObject *phaseroots = NULL; |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
797 PyObject *phasessize = NULL; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
798 PyObject *phasesets[4] = {NULL, NULL, NULL, NULL}; |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
799 Py_ssize_t len = index_length(self); |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
800 const char *currentphase; |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
801 char *phases = NULL; |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
802 int minphaserev = -1, rev, i; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
803 const int numphases = (int)(sizeof(phasesets) / sizeof(phasesets[0])); |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
804 |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
805 if (!PyArg_ParseTuple(args, "O", &roots)) |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
806 return NULL; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
807 if (roots == NULL || !PyDict_Check(roots)) { |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
808 PyErr_SetString(PyExc_TypeError, "roots must be a dictionary"); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
809 return NULL; |
36623
a472a897c340
cext: fix computephasesmapsets() not to return without setting an exception
Yuya Nishihara <yuya@tcha.org>
parents:
36621
diff
changeset
|
810 } |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
811 |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
812 phases = calloc(len, 1); |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
813 if (phases == NULL) { |
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
814 PyErr_NoMemory(); |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
815 return NULL; |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
816 } |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
817 |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
818 for (i = 0; i < numphases; ++i) { |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
819 pyphase = PyInt_FromLong(trackedphases[i]); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
820 if (pyphase == NULL) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
821 goto release; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
822 phaseroots = PyDict_GetItem(roots, pyphase); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
823 Py_DECREF(pyphase); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
824 if (phaseroots == NULL) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
825 continue; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
826 rev = add_roots_get_min(self, phaseroots, phases, trackedphases[i]); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
827 phaseroots = NULL; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
828 if (rev == -2) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
829 goto release; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
830 if (rev != -1 && (minphaserev == -1 || rev < minphaserev)) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
831 minphaserev = rev; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
832 } |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
833 |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
834 for (i = 0; i < numphases; ++i) { |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
835 phasesets[i] = PySet_New(NULL); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
836 if (phasesets[i] == NULL) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
837 goto release; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
838 } |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
839 |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
840 if (minphaserev == -1) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
841 minphaserev = len; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
842 for (rev = minphaserev; rev < len; ++rev) { |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
843 int parents[2]; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
844 /* |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
845 * The parent lookup could be skipped for phaseroots, but |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
846 * phase --force would historically not recompute them |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
847 * correctly, leaving descendents with a lower phase around. |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
848 * As such, unconditionally recompute the phase. |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
849 */ |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
850 if (index_get_parents(self, rev, parents, (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
|
851 goto release; |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
852 set_phase_from_parents(phases, parents[0], parents[1], rev); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
853 switch (phases[rev]) { |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
854 case 0: |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
855 continue; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
856 case 1: |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
857 pyphase = phasesets[0]; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
858 break; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
859 case 2: |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
860 pyphase = phasesets[1]; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
861 break; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
862 case 32: |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
863 pyphase = phasesets[2]; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
864 break; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
865 case 96: |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
866 pyphase = phasesets[3]; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
867 break; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
868 default: |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
869 goto release; |
36623
a472a897c340
cext: fix computephasesmapsets() not to return without setting an exception
Yuya Nishihara <yuya@tcha.org>
parents:
36621
diff
changeset
|
870 } |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
871 pyrev = PyInt_FromLong(rev); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
872 if (pyrev == NULL) |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
873 goto release; |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
874 if (PySet_Add(pyphase, pyrev) == -1) { |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
875 Py_DECREF(pyrev); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
876 goto release; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
877 } |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
878 Py_DECREF(pyrev); |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
879 } |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
880 phaseroots = _dict_new_presized(numphases); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
881 if (phaseroots == NULL) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
882 goto release; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
883 for (int i = 0; i < numphases; ++i) { |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
884 pyphase = PyInt_FromLong(trackedphases[i]); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
885 if (pyphase == NULL) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
886 goto release; |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
887 if (PyDict_SetItem(phaseroots, pyphase, phasesets[i]) == -1) { |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
888 Py_DECREF(pyphase); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
889 goto release; |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
890 } |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
891 Py_DECREF(phasesets[i]); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
892 phasesets[i] = NULL; |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
893 } |
39074
acd23830bcd6
cext: fix most truncation warnings in revlog on Windows
Matt Harbison <matt_harbison@yahoo.com>
parents:
39073
diff
changeset
|
894 phasessize = PyInt_FromSsize_t(len); |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34861
diff
changeset
|
895 if (phasessize == NULL) |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
896 goto release; |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
897 |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
898 ret = PyTuple_Pack(2, phasessize, phaseroots); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
899 Py_DECREF(phasessize); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
900 Py_DECREF(phaseroots); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
901 return ret; |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24879
diff
changeset
|
902 |
27364
ad1cc1435b13
parsers: simplify error logic in compute_phases_map_sets
Bryan O'Sullivan <bos@serpentine.com>
parents:
27341
diff
changeset
|
903 release: |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
904 for (i = 0; i < numphases; ++i) |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
905 Py_XDECREF(phasesets[i]); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
906 Py_XDECREF(phaseroots); |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
907 |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
908 free(phases); |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
44587
diff
changeset
|
909 return NULL; |
24443
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
910 } |
539b3c7eea44
phase: compute phases in C
Laurent Charignon <lcharignon@fb.com>
parents:
24214
diff
changeset
|
911 |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
912 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
|
913 { |
25297
3966e39fea98
changelog: fix bug in heads computation
Laurent Charignon <lcharignon@fb.com>
parents:
25296
diff
changeset
|
914 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
|
915 char *nothead = NULL; |
22540
9a860ac8c216
parsers: fix uninitialize variable warning
David Soria Parra <davidsp@fb.com>
parents:
22484
diff
changeset
|
916 PyObject *heads = NULL; |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
917 PyObject *filter = NULL; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
918 PyObject *filteredrevs = Py_None; |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
919 |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
920 if (!PyArg_ParseTuple(args, "|O", &filteredrevs)) { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
921 return NULL; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
922 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
923 |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
924 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
|
925 return list_copy(self->headrevs); |
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
926 |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
927 Py_DECREF(self->filteredrevs); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
928 self->filteredrevs = filteredrevs; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
929 Py_INCREF(filteredrevs); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
930 |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
931 if (filteredrevs != Py_None) { |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
932 filter = PyObject_GetAttrString(filteredrevs, "__contains__"); |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
933 if (!filter) { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
934 PyErr_SetString( |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
935 PyExc_TypeError, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
936 "filteredrevs has no attribute __contains__"); |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
937 goto bail; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
938 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
939 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
940 |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
941 len = index_length(self); |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
942 heads = PyList_New(0); |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
943 if (heads == NULL) |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
944 goto bail; |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
945 if (len == 0) { |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
946 PyObject *nullid = PyInt_FromLong(-1); |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
947 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
|
948 Py_XDECREF(nullid); |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
949 goto bail; |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
950 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
951 goto done; |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
952 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
953 |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
954 nothead = calloc(len, 1); |
27366
7e8a883da171
parsers: add a missed PyErr_NoMemory
Bryan O'Sullivan <bos@serpentine.com>
parents:
27365
diff
changeset
|
955 if (nothead == NULL) { |
7e8a883da171
parsers: add a missed PyErr_NoMemory
Bryan O'Sullivan <bos@serpentine.com>
parents:
27365
diff
changeset
|
956 PyErr_NoMemory(); |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
957 goto bail; |
27366
7e8a883da171
parsers: add a missed PyErr_NoMemory
Bryan O'Sullivan <bos@serpentine.com>
parents:
27365
diff
changeset
|
958 } |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
959 |
28386
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
960 for (i = len - 1; i >= 0; i--) { |
25297
3966e39fea98
changelog: fix bug in heads computation
Laurent Charignon <lcharignon@fb.com>
parents:
25296
diff
changeset
|
961 int isfiltered; |
3966e39fea98
changelog: fix bug in heads computation
Laurent Charignon <lcharignon@fb.com>
parents:
25296
diff
changeset
|
962 int parents[2]; |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
963 |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
964 /* If nothead[i] == 1, it means we've seen an unfiltered child |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
965 * of this node already, and therefore this node is not |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
966 * filtered. So we can skip the expensive check_filter step. |
28386
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
967 */ |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
968 if (nothead[i] != 1) { |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
969 isfiltered = check_filter(filter, i); |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
970 if (isfiltered == -1) { |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
971 PyErr_SetString(PyExc_TypeError, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
972 "unable to check filter"); |
28386
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
973 goto bail; |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
974 } |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
975 |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
976 if (isfiltered) { |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
977 nothead[i] = 1; |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
978 continue; |
1c658391b22f
parsers: optimize filtered headrevs logic
Durham Goode <durham@fb.com>
parents:
27638
diff
changeset
|
979 } |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
980 } |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
981 |
25860
895f04955a49
parsers: silence warning of implicit integer conversion issued by clang
Yuya Nishihara <yuya@tcha.org>
parents:
25810
diff
changeset
|
982 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
|
983 goto bail; |
25297
3966e39fea98
changelog: fix bug in heads computation
Laurent Charignon <lcharignon@fb.com>
parents:
25296
diff
changeset
|
984 for (j = 0; j < 2; j++) { |
3966e39fea98
changelog: fix bug in heads computation
Laurent Charignon <lcharignon@fb.com>
parents:
25296
diff
changeset
|
985 if (parents[j] >= 0) |
3966e39fea98
changelog: fix bug in heads computation
Laurent Charignon <lcharignon@fb.com>
parents:
25296
diff
changeset
|
986 nothead[parents[j]] = 1; |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
987 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
988 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
989 |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
990 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
|
991 PyObject *head; |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
992 |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
993 if (nothead[i]) |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
994 continue; |
22400
888bc106de83
parsers: fix typing issue when constructing Python integer object
Henrik Stuart <hg@hstuart.dk>
parents:
22399
diff
changeset
|
995 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
|
996 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
|
997 Py_XDECREF(head); |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
998 goto bail; |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
999 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
1000 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
1001 |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
1002 done: |
16787
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
1003 self->headrevs = heads; |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
1004 Py_XDECREF(filter); |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
1005 free(nothead); |
16787
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
1006 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
|
1007 bail: |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
1008 Py_XDECREF(filter); |
16786
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
1009 Py_XDECREF(heads); |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
1010 free(nothead); |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
1011 return NULL; |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
1012 } |
2631cd5dd244
revlog: switch to a C version of headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16784
diff
changeset
|
1013 |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
1014 /** |
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
1015 * 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
|
1016 * |
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
1017 * 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
|
1018 */ |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1019 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
|
1020 { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1021 const char *data; |
41018
f4113489e4d4
revlog: catch revlog corruption in index_baserev
Boris Feld <boris.feld@octobus.net>
parents:
40813
diff
changeset
|
1022 int result; |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1023 |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
1024 if (rev >= self->length) { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1025 PyObject *tuple = |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1026 PyList_GET_ITEM(self->added, rev - self->length); |
40598
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
1027 long ret; |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
1028 if (!pylong_to_long(PyTuple_GET_ITEM(tuple, 3), &ret)) { |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
1029 return -2; |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
1030 } |
41078 | 1031 result = (int)ret; |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1032 } else { |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1033 data = index_deref(self, rev); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1034 if (data == NULL) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1035 return -2; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1036 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1037 |
41018
f4113489e4d4
revlog: catch revlog corruption in index_baserev
Boris Feld <boris.feld@octobus.net>
parents:
40813
diff
changeset
|
1038 result = getbe32(data + 16); |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1039 } |
41018
f4113489e4d4
revlog: catch revlog corruption in index_baserev
Boris Feld <boris.feld@octobus.net>
parents:
40813
diff
changeset
|
1040 if (result > rev) { |
f4113489e4d4
revlog: catch revlog corruption in index_baserev
Boris Feld <boris.feld@octobus.net>
parents:
40813
diff
changeset
|
1041 PyErr_Format( |
f4113489e4d4
revlog: catch revlog corruption in index_baserev
Boris Feld <boris.feld@octobus.net>
parents:
40813
diff
changeset
|
1042 PyExc_ValueError, |
f4113489e4d4
revlog: catch revlog corruption in index_baserev
Boris Feld <boris.feld@octobus.net>
parents:
40813
diff
changeset
|
1043 "corrupted revlog, revision base above revision: %d, %d", |
f4113489e4d4
revlog: catch revlog corruption in index_baserev
Boris Feld <boris.feld@octobus.net>
parents:
40813
diff
changeset
|
1044 rev, result); |
f4113489e4d4
revlog: catch revlog corruption in index_baserev
Boris Feld <boris.feld@octobus.net>
parents:
40813
diff
changeset
|
1045 return -2; |
f4113489e4d4
revlog: catch revlog corruption in index_baserev
Boris Feld <boris.feld@octobus.net>
parents:
40813
diff
changeset
|
1046 } |
41019
7542466b94e2
revlog: cache delta base value under -1
Boris Feld <boris.feld@octobus.net>
parents:
41018
diff
changeset
|
1047 if (result < -1) { |
7542466b94e2
revlog: cache delta base value under -1
Boris Feld <boris.feld@octobus.net>
parents:
41018
diff
changeset
|
1048 PyErr_Format( |
7542466b94e2
revlog: cache delta base value under -1
Boris Feld <boris.feld@octobus.net>
parents:
41018
diff
changeset
|
1049 PyExc_ValueError, |
41283
4948b327d3b9
cext: clang-format new code coming from stable branch
Yuya Nishihara <yuya@tcha.org>
parents:
41129
diff
changeset
|
1050 "corrupted revlog, revision base out of range: %d, %d", rev, |
4948b327d3b9
cext: clang-format new code coming from stable branch
Yuya Nishihara <yuya@tcha.org>
parents:
41129
diff
changeset
|
1051 result); |
41019
7542466b94e2
revlog: cache delta base value under -1
Boris Feld <boris.feld@octobus.net>
parents:
41018
diff
changeset
|
1052 return -2; |
7542466b94e2
revlog: cache delta base value under -1
Boris Feld <boris.feld@octobus.net>
parents:
41018
diff
changeset
|
1053 } |
41018
f4113489e4d4
revlog: catch revlog corruption in index_baserev
Boris Feld <boris.feld@octobus.net>
parents:
40813
diff
changeset
|
1054 return result; |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1055 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1056 |
41085
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1057 /** |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1058 * Find if a revision is a snapshot or not |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1059 * |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1060 * Only relevant for sparse-revlog case. |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1061 * Callers must ensure that rev is in a valid range. |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1062 */ |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1063 static int index_issnapshotrev(indexObject *self, Py_ssize_t rev) |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1064 { |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1065 int ps[2]; |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1066 Py_ssize_t base; |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1067 while (rev >= 0) { |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1068 base = (Py_ssize_t)index_baserev(self, rev); |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1069 if (base == rev) { |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1070 base = -1; |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1071 } |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1072 if (base == -2) { |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1073 assert(PyErr_Occurred()); |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1074 return -1; |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1075 } |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1076 if (base == -1) { |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1077 return 1; |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1078 } |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1079 if (index_get_parents(self, rev, ps, (int)rev) < 0) { |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1080 assert(PyErr_Occurred()); |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1081 return -1; |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1082 }; |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1083 if (base == ps[0] || base == ps[1]) { |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1084 return 0; |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1085 } |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1086 rev = base; |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1087 } |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1088 return rev == -1; |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1089 } |
a6556b09bf83
revlog: add a native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41078
diff
changeset
|
1090 |
41086
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1091 static PyObject *index_issnapshot(indexObject *self, PyObject *value) |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1092 { |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1093 long rev; |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1094 int issnap; |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1095 Py_ssize_t length = index_length(self); |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1096 |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1097 if (!pylong_to_long(value, &rev)) { |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1098 return NULL; |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1099 } |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1100 if (rev < -1 || rev >= length) { |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1101 PyErr_Format(PyExc_ValueError, "revlog index out of range: %ld", |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1102 rev); |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1103 return NULL; |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1104 }; |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1105 issnap = index_issnapshotrev(self, (Py_ssize_t)rev); |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1106 if (issnap < 0) { |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1107 return NULL; |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1108 }; |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1109 return PyBool_FromLong((long)issnap); |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1110 } |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
1111 |
41108
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1112 static PyObject *index_findsnapshots(indexObject *self, PyObject *args) |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1113 { |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1114 Py_ssize_t start_rev; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1115 PyObject *cache; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1116 Py_ssize_t base; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1117 Py_ssize_t rev; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1118 PyObject *key = NULL; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1119 PyObject *value = NULL; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1120 const Py_ssize_t length = index_length(self); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1121 if (!PyArg_ParseTuple(args, "O!n", &PyDict_Type, &cache, &start_rev)) { |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1122 return NULL; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1123 } |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1124 for (rev = start_rev; rev < length; rev++) { |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1125 int issnap; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1126 PyObject *allvalues = NULL; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1127 issnap = index_issnapshotrev(self, rev); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1128 if (issnap < 0) { |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1129 goto bail; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1130 } |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1131 if (issnap == 0) { |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1132 continue; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1133 } |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1134 base = (Py_ssize_t)index_baserev(self, rev); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1135 if (base == rev) { |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1136 base = -1; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1137 } |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1138 if (base == -2) { |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1139 assert(PyErr_Occurred()); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1140 goto bail; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1141 } |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1142 key = PyInt_FromSsize_t(base); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1143 allvalues = PyDict_GetItem(cache, key); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1144 if (allvalues == NULL && PyErr_Occurred()) { |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1145 goto bail; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1146 } |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1147 if (allvalues == NULL) { |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1148 int r; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1149 allvalues = PyList_New(0); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1150 if (!allvalues) { |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1151 goto bail; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1152 } |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1153 r = PyDict_SetItem(cache, key, allvalues); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1154 Py_DECREF(allvalues); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1155 if (r < 0) { |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1156 goto bail; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1157 } |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1158 } |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1159 value = PyInt_FromSsize_t(rev); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1160 if (PyList_Append(allvalues, value)) { |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1161 goto bail; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1162 } |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1163 Py_CLEAR(key); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1164 Py_CLEAR(value); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1165 } |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1166 Py_RETURN_NONE; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1167 bail: |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1168 Py_XDECREF(key); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1169 Py_XDECREF(value); |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1170 return NULL; |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1171 } |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
1172 |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1173 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
|
1174 { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1175 int rev, generaldelta; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1176 PyObject *stoparg; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1177 int stoprev, iterrev, baserev = -1; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1178 int stopped; |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
1179 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
|
1180 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
|
1181 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1182 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
|
1183 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1184 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1185 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1186 if (PyInt_Check(stoparg)) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1187 stoprev = (int)PyInt_AsLong(stoparg); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1188 if (stoprev == -1 && PyErr_Occurred()) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1189 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1190 } |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1191 } else if (stoparg == Py_None) { |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1192 stoprev = -2; |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1193 } else { |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1194 PyErr_SetString(PyExc_ValueError, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1195 "stoprev must be integer or None"); |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1196 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1197 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1198 |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
1199 if (rev < 0 || rev >= length) { |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1200 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
|
1201 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1202 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1203 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1204 chain = PyList_New(0); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1205 if (chain == NULL) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1206 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1207 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1208 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1209 baserev = index_baserev(self, rev); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1210 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1211 /* This should never happen. */ |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
1212 if (baserev <= -2) { |
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
1213 /* 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
|
1214 assert(PyErr_Occurred()); |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1215 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1216 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1217 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1218 iterrev = rev; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1219 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1220 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
|
1221 PyObject *value = PyInt_FromLong(iterrev); |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1222 if (value == NULL) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1223 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1224 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1225 if (PyList_Append(chain, value)) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1226 Py_DECREF(value); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1227 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1228 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1229 Py_DECREF(value); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1230 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1231 if (generaldelta) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1232 iterrev = baserev; |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1233 } else { |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1234 iterrev--; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1235 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1236 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1237 if (iterrev < 0) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1238 break; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1239 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1240 |
38868
0db50770f388
index: don't add 1 to length variables
Martin von Zweigbergk <martinvonz@google.com>
parents:
38867
diff
changeset
|
1241 if (iterrev >= length) { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1242 PyErr_SetString(PyExc_IndexError, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1243 "revision outside index"); |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1244 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1245 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1246 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1247 baserev = index_baserev(self, iterrev); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1248 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1249 /* This should never happen. */ |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
1250 if (baserev <= -2) { |
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
1251 /* 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
|
1252 assert(PyErr_Occurred()); |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1253 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1254 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1255 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1256 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1257 if (iterrev == stoprev) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1258 stopped = 1; |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1259 } else { |
33174
f4f52bb362e6
revlog: address review feedback for deltachain C implementation
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33171
diff
changeset
|
1260 PyObject *value = PyInt_FromLong(iterrev); |
33171
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1261 if (value == NULL) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1262 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1263 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1264 if (PyList_Append(chain, value)) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1265 Py_DECREF(value); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1266 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1267 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1268 Py_DECREF(value); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1269 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1270 stopped = 0; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1271 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1272 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1273 if (PyList_Reverse(chain)) { |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1274 goto bail; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1275 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1276 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1277 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
|
1278 Py_DECREF(chain); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1279 return result; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1280 |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1281 bail: |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1282 Py_DECREF(chain); |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1283 return NULL; |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1284 } |
6d678ab1b10d
revlog: C implementation of delta chain resolution
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32384
diff
changeset
|
1285 |
40705
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1286 static inline int64_t |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1287 index_segment_span(indexObject *self, Py_ssize_t start_rev, Py_ssize_t end_rev) |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1288 { |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1289 int64_t start_offset; |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1290 int64_t end_offset; |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1291 int end_size; |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1292 start_offset = index_get_start(self, start_rev); |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1293 if (start_offset < 0) { |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1294 return -1; |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1295 } |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1296 end_offset = index_get_start(self, end_rev); |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1297 if (end_offset < 0) { |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1298 return -1; |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1299 } |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1300 end_size = index_get_length(self, end_rev); |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1301 if (end_size < 0) { |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1302 return -1; |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1303 } |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1304 if (end_offset < start_offset) { |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1305 PyErr_Format(PyExc_ValueError, |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1306 "corrupted revlog index: inconsistent offset " |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1307 "between revisions (%zd) and (%zd)", |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1308 start_rev, end_rev); |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1309 return -1; |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1310 } |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1311 return (end_offset - start_offset) + (int64_t)end_size; |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1312 } |
4ec6a24029d2
sparse-revlog: add a `index_segment_span` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40704
diff
changeset
|
1313 |
40742
8edca70dc951
revlog: update the documentation for `trim_endidx`
Boris Feld <boris.feld@octobus.net>
parents:
40741
diff
changeset
|
1314 /* returns endidx so that revs[startidx:endidx] has no empty trailing revs */ |
40706
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1315 static Py_ssize_t trim_endidx(indexObject *self, const Py_ssize_t *revs, |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1316 Py_ssize_t startidx, Py_ssize_t endidx) |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1317 { |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1318 int length; |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1319 while (endidx > 1 && endidx > startidx) { |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1320 length = index_get_length(self, revs[endidx - 1]); |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1321 if (length < 0) { |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1322 return -1; |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1323 } |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1324 if (length != 0) { |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1325 break; |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1326 } |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1327 endidx -= 1; |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1328 } |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1329 return endidx; |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1330 } |
0650be877a37
sparse-revlog: add a `trim_endidx` function in C
Boris Feld <boris.feld@octobus.net>
parents:
40705
diff
changeset
|
1331 |
40707
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1332 struct Gap { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1333 int64_t size; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1334 Py_ssize_t idx; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1335 }; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1336 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1337 static int gap_compare(const void *left, const void *right) |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1338 { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1339 const struct Gap *l_left = ((const struct Gap *)left); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1340 const struct Gap *l_right = ((const struct Gap *)right); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1341 if (l_left->size < l_right->size) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1342 return -1; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1343 } else if (l_left->size > l_right->size) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1344 return 1; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1345 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1346 return 0; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1347 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1348 static int Py_ssize_t_compare(const void *left, const void *right) |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1349 { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1350 const Py_ssize_t l_left = *(const Py_ssize_t *)left; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1351 const Py_ssize_t l_right = *(const Py_ssize_t *)right; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1352 if (l_left < l_right) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1353 return -1; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1354 } else if (l_left > l_right) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1355 return 1; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1356 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1357 return 0; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1358 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1359 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1360 static PyObject *index_slicechunktodensity(indexObject *self, PyObject *args) |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1361 { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1362 /* method arguments */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1363 PyObject *list_revs = NULL; /* revisions in the chain */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1364 double targetdensity = 0; /* min density to achieve */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1365 Py_ssize_t mingapsize = 0; /* threshold to ignore gaps */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1366 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1367 /* other core variables */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1368 Py_ssize_t idxlen = index_length(self); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1369 Py_ssize_t i; /* used for various iteration */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1370 PyObject *result = NULL; /* the final return of the function */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1371 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1372 /* generic information about the delta chain being slice */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1373 Py_ssize_t num_revs = 0; /* size of the full delta chain */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1374 Py_ssize_t *revs = NULL; /* native array of revision in the chain */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1375 int64_t chainpayload = 0; /* sum of all delta in the chain */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1376 int64_t deltachainspan = 0; /* distance from first byte to last byte */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1377 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1378 /* variable used for slicing the delta chain */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1379 int64_t readdata = 0; /* amount of data currently planned to be read */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1380 double density = 0; /* ration of payload data compared to read ones */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1381 int64_t previous_end; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1382 struct Gap *gaps = NULL; /* array of notable gap in the chain */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1383 Py_ssize_t num_gaps = |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1384 0; /* total number of notable gap recorded so far */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1385 Py_ssize_t *selected_indices = NULL; /* indices of gap skipped over */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1386 Py_ssize_t num_selected = 0; /* number of gaps skipped */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1387 PyObject *chunk = NULL; /* individual slice */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1388 PyObject *allchunks = NULL; /* all slices */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1389 Py_ssize_t previdx; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1390 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1391 /* parsing argument */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1392 if (!PyArg_ParseTuple(args, "O!dn", &PyList_Type, &list_revs, |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1393 &targetdensity, &mingapsize)) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1394 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1395 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1396 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1397 /* If the delta chain contains a single element, we do not need slicing |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1398 */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1399 num_revs = PyList_GET_SIZE(list_revs); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1400 if (num_revs <= 1) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1401 result = PyTuple_Pack(1, list_revs); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1402 goto done; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1403 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1404 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1405 /* Turn the python list into a native integer array (for efficiency) */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1406 revs = (Py_ssize_t *)calloc(num_revs, sizeof(Py_ssize_t)); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1407 if (revs == NULL) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1408 PyErr_NoMemory(); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1409 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1410 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1411 for (i = 0; i < num_revs; i++) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1412 Py_ssize_t revnum = PyInt_AsLong(PyList_GET_ITEM(list_revs, i)); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1413 if (revnum == -1 && PyErr_Occurred()) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1414 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1415 } |
40963
2e305e54eae3
sparse-revlog: protect C code against delta chain including nullrev
Boris Feld <boris.feld@octobus.net>
parents:
40962
diff
changeset
|
1416 if (revnum < nullrev || revnum >= idxlen) { |
40756
c85964d715fd
sparse: raise a move verbose index error from the C code
Boris Feld <boris.feld@octobus.net>
parents:
40742
diff
changeset
|
1417 PyErr_Format(PyExc_IndexError, |
c85964d715fd
sparse: raise a move verbose index error from the C code
Boris Feld <boris.feld@octobus.net>
parents:
40742
diff
changeset
|
1418 "index out of range: %zd", revnum); |
40707
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1419 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1420 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1421 revs[i] = revnum; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1422 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1423 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1424 /* Compute and check various property of the unsliced delta chain */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1425 deltachainspan = index_segment_span(self, revs[0], revs[num_revs - 1]); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1426 if (deltachainspan < 0) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1427 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1428 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1429 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1430 if (deltachainspan <= mingapsize) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1431 result = PyTuple_Pack(1, list_revs); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1432 goto done; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1433 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1434 chainpayload = 0; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1435 for (i = 0; i < num_revs; i++) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1436 int tmp = index_get_length(self, revs[i]); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1437 if (tmp < 0) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1438 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1439 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1440 chainpayload += tmp; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1441 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1442 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1443 readdata = deltachainspan; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1444 density = 1.0; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1445 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1446 if (0 < deltachainspan) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1447 density = (double)chainpayload / (double)deltachainspan; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1448 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1449 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1450 if (density >= targetdensity) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1451 result = PyTuple_Pack(1, list_revs); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1452 goto done; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1453 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1454 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1455 /* if chain is too sparse, look for relevant gaps */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1456 gaps = (struct Gap *)calloc(num_revs, sizeof(struct Gap)); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1457 if (gaps == NULL) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1458 PyErr_NoMemory(); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1459 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1460 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1461 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1462 previous_end = -1; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1463 for (i = 0; i < num_revs; i++) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1464 int64_t revstart; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1465 int revsize; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1466 revstart = index_get_start(self, revs[i]); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1467 if (revstart < 0) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1468 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1469 }; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1470 revsize = index_get_length(self, revs[i]); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1471 if (revsize < 0) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1472 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1473 }; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1474 if (revsize == 0) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1475 continue; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1476 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1477 if (previous_end >= 0) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1478 int64_t gapsize = revstart - previous_end; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1479 if (gapsize > mingapsize) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1480 gaps[num_gaps].size = gapsize; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1481 gaps[num_gaps].idx = i; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1482 num_gaps += 1; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1483 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1484 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1485 previous_end = revstart + revsize; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1486 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1487 if (num_gaps == 0) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1488 result = PyTuple_Pack(1, list_revs); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1489 goto done; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1490 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1491 qsort(gaps, num_gaps, sizeof(struct Gap), &gap_compare); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1492 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1493 /* Slice the largest gap first, they improve the density the most */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1494 selected_indices = |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1495 (Py_ssize_t *)malloc((num_gaps + 1) * sizeof(Py_ssize_t)); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1496 if (selected_indices == NULL) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1497 PyErr_NoMemory(); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1498 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1499 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1500 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1501 for (i = num_gaps - 1; i >= 0; i--) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1502 selected_indices[num_selected] = gaps[i].idx; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1503 readdata -= gaps[i].size; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1504 num_selected += 1; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1505 if (readdata <= 0) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1506 density = 1.0; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1507 } else { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1508 density = (double)chainpayload / (double)readdata; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1509 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1510 if (density >= targetdensity) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1511 break; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1512 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1513 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1514 qsort(selected_indices, num_selected, sizeof(Py_ssize_t), |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1515 &Py_ssize_t_compare); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1516 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1517 /* create the resulting slice */ |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1518 allchunks = PyList_New(0); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1519 if (allchunks == NULL) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1520 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1521 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1522 previdx = 0; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1523 selected_indices[num_selected] = num_revs; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1524 for (i = 0; i <= num_selected; i++) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1525 Py_ssize_t idx = selected_indices[i]; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1526 Py_ssize_t endidx = trim_endidx(self, revs, previdx, idx); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1527 if (endidx < 0) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1528 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1529 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1530 if (previdx < endidx) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1531 chunk = PyList_GetSlice(list_revs, previdx, endidx); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1532 if (chunk == NULL) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1533 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1534 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1535 if (PyList_Append(allchunks, chunk) == -1) { |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1536 goto bail; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1537 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1538 Py_DECREF(chunk); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1539 chunk = NULL; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1540 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1541 previdx = idx; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1542 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1543 result = allchunks; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1544 goto done; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1545 |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1546 bail: |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1547 Py_XDECREF(allchunks); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1548 Py_XDECREF(chunk); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1549 done: |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1550 free(revs); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1551 free(gaps); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1552 free(selected_indices); |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1553 return result; |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1554 } |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
1555 |
16618
6bae941b58ad
parsers: change the type of nt_level
Bryan O'Sullivan <bryano@fb.com>
parents:
16617
diff
changeset
|
1556 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
|
1557 { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1558 int v = node[level >> 1]; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1559 if (!(level & 1)) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1560 v >>= 4; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1561 return v & 0xf; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1562 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1563 |
16616
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
1564 /* |
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
1565 * Return values: |
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
1566 * |
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
1567 * -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
|
1568 * -2: not found |
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
1569 * rest: valid rev |
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
1570 */ |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1571 static int nt_find(nodetree *self, const char *node, Py_ssize_t nodelen, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1572 int hex) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1573 { |
16663 | 1574 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
|
1575 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
|
1576 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1577 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
|
1578 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1579 |
16663 | 1580 if (hex) |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1581 maxlevel = nodelen > 40 ? 40 : (int)nodelen; |
16663 | 1582 else |
1583 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
|
1584 |
e6dfbc5df76f
parsers: use the correct maximum radix tree depth
Bryan O'Sullivan <bryano@fb.com>
parents:
16604
diff
changeset
|
1585 for (level = off = 0; level < maxlevel; level++) { |
16663 | 1586 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
|
1587 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
|
1588 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
|
1589 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1590 if (v < 0) { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1591 const char *n; |
16663 | 1592 Py_ssize_t i; |
1593 | |
38846
f738c502e43b
index: store nullrev as -1 in nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38845
diff
changeset
|
1594 v = -(v + 2); |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1595 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
|
1596 if (n == NULL) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1597 return -2; |
16663 | 1598 for (i = level; i < maxlevel; i++) |
1599 if (getnybble(node, i) != nt_level(n, i)) | |
1600 return -2; | |
1601 return v; | |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1602 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1603 if (v == 0) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1604 return -2; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1605 off = v; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1606 } |
16616
8f79aabd96f6
parsers: allow nt_find to signal an ambiguous match
Bryan O'Sullivan <bryano@fb.com>
parents:
16615
diff
changeset
|
1607 /* 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
|
1608 return -4; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1609 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1610 |
38915
fff675dfb80b
index: pass only nodetree to nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38914
diff
changeset
|
1611 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
|
1612 { |
38915
fff675dfb80b
index: pass only nodetree to nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38914
diff
changeset
|
1613 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
|
1614 unsigned newcapacity; |
dcd395dc98d8
index: remove side-effect from failed nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38937
diff
changeset
|
1615 nodetreenode *newnodes; |
39071
06ff7ea4f440
index: avoid duplicating capacity-growth expression
Martin von Zweigbergk <martinvonz@google.com>
parents:
39070
diff
changeset
|
1616 newcapacity = self->capacity * 2; |
06ff7ea4f440
index: avoid duplicating capacity-growth expression
Martin von Zweigbergk <martinvonz@google.com>
parents:
39070
diff
changeset
|
1617 if (newcapacity >= INT_MAX / sizeof(nodetreenode)) { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1618 PyErr_SetString(PyExc_MemoryError, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1619 "overflow in nt_new"); |
24623
2262d7bc469e
parsers: check for memory allocation overflows more carefully
Bryan O'Sullivan <bryano@fb.com>
parents:
24622
diff
changeset
|
1620 return -1; |
2262d7bc469e
parsers: check for memory allocation overflows more carefully
Bryan O'Sullivan <bryano@fb.com>
parents:
24622
diff
changeset
|
1621 } |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1622 newnodes = |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1623 realloc(self->nodes, newcapacity * sizeof(nodetreenode)); |
38938
dcd395dc98d8
index: remove side-effect from failed nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38937
diff
changeset
|
1624 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
|
1625 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
|
1626 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1627 } |
38938
dcd395dc98d8
index: remove side-effect from failed nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38937
diff
changeset
|
1628 self->capacity = newcapacity; |
dcd395dc98d8
index: remove side-effect from failed nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38937
diff
changeset
|
1629 self->nodes = newnodes; |
38915
fff675dfb80b
index: pass only nodetree to nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38914
diff
changeset
|
1630 memset(&self->nodes[self->length], 0, |
fff675dfb80b
index: pass only nodetree to nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38914
diff
changeset
|
1631 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
|
1632 } |
38915
fff675dfb80b
index: pass only nodetree to nt_new()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38914
diff
changeset
|
1633 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
|
1634 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1635 |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1636 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
|
1637 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1638 int level = 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1639 int off = 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1640 |
16641
e6dfbc5df76f
parsers: use the correct maximum radix tree depth
Bryan O'Sullivan <bryano@fb.com>
parents:
16604
diff
changeset
|
1641 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
|
1642 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
|
1643 nodetreenode *n; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1644 int v; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1645 |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1646 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
|
1647 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
|
1648 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1649 if (v == 0) { |
38846
f738c502e43b
index: store nullrev as -1 in nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38845
diff
changeset
|
1650 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
|
1651 return 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1652 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1653 if (v < 0) { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1654 const char *oldnode = |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1655 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
|
1656 int noff; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1657 |
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
|
1658 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
|
1659 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
|
1660 if (!memcmp(oldnode, node, 20)) { |
38846
f738c502e43b
index: store nullrev as -1 in nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38845
diff
changeset
|
1661 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
|
1662 return 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1663 } |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1664 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
|
1665 if (noff == -1) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1666 return -1; |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1667 /* 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
|
1668 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
|
1669 off = noff; |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1670 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
|
1671 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
|
1672 if (level > self->depth) |
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1673 self->depth = level; |
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1674 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
|
1675 } else { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1676 level += 1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1677 off = v; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1678 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1679 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1680 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1681 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1682 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1683 |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1684 static PyObject *ntobj_insert(nodetreeObject *self, PyObject *args) |
39226
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1685 { |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1686 Py_ssize_t rev; |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1687 const char *node; |
39227
42cc76d0f836
cext: fix revlog compiler error on Windows
Matt Harbison <matt_harbison@yahoo.com>
parents:
39226
diff
changeset
|
1688 Py_ssize_t length; |
39226
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1689 if (!PyArg_ParseTuple(args, "n", &rev)) |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1690 return NULL; |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1691 length = index_length(self->nt.index); |
39226
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1692 if (rev < 0 || rev >= length) { |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1693 PyErr_SetString(PyExc_ValueError, "revlog index out of range"); |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1694 return NULL; |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1695 } |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1696 node = index_node_existing(self->nt.index, rev); |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1697 if (nt_insert(&self->nt, node, (int)rev) == -1) |
39226
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1698 return NULL; |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1699 Py_RETURN_NONE; |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1700 } |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1701 |
38940
b6fb71a0a005
index: make most "nt_*" functions take a nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38939
diff
changeset
|
1702 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
|
1703 { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1704 /* rev==-2 happens to get encoded as 0, which is interpreted as not set |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1705 */ |
38846
f738c502e43b
index: store nullrev as -1 in nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38845
diff
changeset
|
1706 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
|
1707 } |
f9fc59ea3135
index: create function for deleting node from nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38821
diff
changeset
|
1708 |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1709 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
|
1710 { |
39225
fcaffbd7e635
index: fix a comment about overflow-checking
Martin von Zweigbergk <martinvonz@google.com>
parents:
39219
diff
changeset
|
1711 /* Initialize before overflow-checking to avoid nt_dealloc() crash. */ |
39218
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1712 self->nodes = NULL; |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1713 |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1714 self->index = index; |
39072
34eb999e29bf
index: make capacity argument to nt_init be measured in revisions
Martin von Zweigbergk <martinvonz@google.com>
parents:
39071
diff
changeset
|
1715 /* The input capacity is in terms of revisions, while the field is in |
34eb999e29bf
index: make capacity argument to nt_init be measured in revisions
Martin von Zweigbergk <martinvonz@google.com>
parents:
39071
diff
changeset
|
1716 * terms of nodetree nodes. */ |
34eb999e29bf
index: make capacity argument to nt_init be measured in revisions
Martin von Zweigbergk <martinvonz@google.com>
parents:
39071
diff
changeset
|
1717 self->capacity = (capacity < 4 ? 4 : capacity / 2); |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1718 self->depth = 0; |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1719 self->splits = 0; |
39070
4dd92a15fcca
index: move check for too large capacity into nt_init()
Martin von Zweigbergk <martinvonz@google.com>
parents:
39069
diff
changeset
|
1720 if ((size_t)self->capacity > INT_MAX / sizeof(nodetreenode)) { |
4dd92a15fcca
index: move check for too large capacity into nt_init()
Martin von Zweigbergk <martinvonz@google.com>
parents:
39069
diff
changeset
|
1721 PyErr_SetString(PyExc_ValueError, "overflow in init_nt"); |
4dd92a15fcca
index: move check for too large capacity into nt_init()
Martin von Zweigbergk <martinvonz@google.com>
parents:
39069
diff
changeset
|
1722 return -1; |
4dd92a15fcca
index: move check for too large capacity into nt_init()
Martin von Zweigbergk <martinvonz@google.com>
parents:
39069
diff
changeset
|
1723 } |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1724 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
|
1725 if (self->nodes == NULL) { |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1726 PyErr_NoMemory(); |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1727 return -1; |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1728 } |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1729 self->length = 1; |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1730 return 0; |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1731 } |
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1732 |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1733 static int ntobj_init(nodetreeObject *self, PyObject *args) |
39218
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1734 { |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1735 PyObject *index; |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1736 unsigned capacity; |
40860
18a8def6e1b5
revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol
Yuya Nishihara <yuya@tcha.org>
parents:
40859
diff
changeset
|
1737 if (!PyArg_ParseTuple(args, "O!I", &HgRevlogIndex_Type, &index, |
18a8def6e1b5
revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol
Yuya Nishihara <yuya@tcha.org>
parents:
40859
diff
changeset
|
1738 &capacity)) |
39218
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1739 return -1; |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1740 Py_INCREF(index); |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1741 return nt_init(&self->nt, (indexObject *)index, capacity); |
39218
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1742 } |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1743 |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1744 static int nt_partialmatch(nodetree *self, const char *node, Py_ssize_t nodelen) |
38943
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1745 { |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1746 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
|
1747 } |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1748 |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1749 /* |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1750 * 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
|
1751 * |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1752 * Return values: |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1753 * |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1754 * -3: error (exception set) |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1755 * -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
|
1756 * rest: length of shortest prefix |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1757 */ |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1758 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
|
1759 { |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1760 int level, off; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1761 |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1762 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
|
1763 int k, v; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1764 nodetreenode *n = &self->nodes[off]; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1765 k = nt_level(node, level); |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1766 v = n->children[k]; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1767 if (v < 0) { |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1768 const char *n; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1769 v = -(v + 2); |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1770 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
|
1771 if (n == NULL) |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1772 return -3; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1773 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
|
1774 /* |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1775 * 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
|
1776 * 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
|
1777 * not exist). |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1778 */ |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1779 return -2; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1780 return level + 1; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1781 } |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1782 if (v == 0) |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1783 return -2; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1784 off = v; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1785 } |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1786 /* |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1787 * 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
|
1788 * 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
|
1789 * 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
|
1790 */ |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1791 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
|
1792 return -3; |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1793 } |
2b89e20c450c
index: move all "nt_*" functions to one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
38942
diff
changeset
|
1794 |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1795 static PyObject *ntobj_shortest(nodetreeObject *self, PyObject *args) |
39226
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1796 { |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1797 PyObject *val; |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1798 char *node; |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1799 int length; |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1800 |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1801 if (!PyArg_ParseTuple(args, "O", &val)) |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1802 return NULL; |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1803 if (node_check(val, &node) == -1) |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1804 return NULL; |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1805 |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1806 length = nt_shortest(&self->nt, node); |
39226
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1807 if (length == -3) |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1808 return NULL; |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1809 if (length == -2) { |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1810 raise_revlog_error(); |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1811 return NULL; |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1812 } |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1813 return PyInt_FromLong(length); |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1814 } |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1815 |
39218
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1816 static void nt_dealloc(nodetree *self) |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1817 { |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1818 free(self->nodes); |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1819 self->nodes = NULL; |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1820 } |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1821 |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1822 static void ntobj_dealloc(nodetreeObject *self) |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1823 { |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1824 Py_XDECREF(self->nt.index); |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1825 nt_dealloc(&self->nt); |
39218
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1826 PyObject_Del(self); |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1827 } |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1828 |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1829 static PyMethodDef ntobj_methods[] = { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1830 {"insert", (PyCFunction)ntobj_insert, METH_VARARGS, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1831 "insert an index entry"}, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1832 {"shortest", (PyCFunction)ntobj_shortest, METH_VARARGS, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1833 "find length of shortest hex nodeid of a binary ID"}, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1834 {NULL} /* Sentinel */ |
39226
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1835 }; |
7a759ad2d06d
shortest: use nodetree for finding shortest node within revset
Martin von Zweigbergk <martinvonz@google.com>
parents:
39225
diff
changeset
|
1836 |
39218
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1837 static PyTypeObject nodetreeType = { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1838 PyVarObject_HEAD_INIT(NULL, 0) /* header */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1839 "parsers.nodetree", /* tp_name */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1840 sizeof(nodetreeObject), /* tp_basicsize */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1841 0, /* tp_itemsize */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1842 (destructor)ntobj_dealloc, /* tp_dealloc */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1843 0, /* tp_print */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1844 0, /* tp_getattr */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1845 0, /* tp_setattr */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1846 0, /* tp_compare */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1847 0, /* tp_repr */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1848 0, /* tp_as_number */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1849 0, /* tp_as_sequence */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1850 0, /* tp_as_mapping */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1851 0, /* tp_hash */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1852 0, /* tp_call */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1853 0, /* tp_str */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1854 0, /* tp_getattro */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1855 0, /* tp_setattro */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1856 0, /* tp_as_buffer */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1857 Py_TPFLAGS_DEFAULT, /* tp_flags */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1858 "nodetree", /* tp_doc */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1859 0, /* tp_traverse */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1860 0, /* tp_clear */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1861 0, /* tp_richcompare */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1862 0, /* tp_weaklistoffset */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1863 0, /* tp_iter */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1864 0, /* tp_iternext */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1865 ntobj_methods, /* tp_methods */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1866 0, /* tp_members */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1867 0, /* tp_getset */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1868 0, /* tp_base */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1869 0, /* tp_dict */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1870 0, /* tp_descr_get */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1871 0, /* tp_descr_set */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1872 0, /* tp_dictoffset */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1873 (initproc)ntobj_init, /* tp_init */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1874 0, /* tp_alloc */ |
39218
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1875 }; |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
1876 |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1877 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
|
1878 { |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1879 if (!self->ntinitialized) { |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1880 if (nt_init(&self->nt, self, (int)self->raw_length) == -1) { |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1881 nt_dealloc(&self->nt); |
38912
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
1882 return -1; |
d1bc0e7c862b
index: extract a type for the nodetree
Martin von Zweigbergk <martinvonz@google.com>
parents:
38911
diff
changeset
|
1883 } |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1884 if (nt_insert(&self->nt, nullid, -1) == -1) { |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1885 nt_dealloc(&self->nt); |
16615
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1886 return -1; |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1887 } |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1888 self->ntinitialized = 1; |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
1889 self->ntrev = (int)index_length(self); |
16615
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1890 self->ntlookups = 1; |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1891 self->ntmisses = 0; |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1892 } |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1893 return 0; |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1894 } |
96fa9dd1db38
parsers: factor out radix tree initialization
Bryan O'Sullivan <bryano@fb.com>
parents:
16614
diff
changeset
|
1895 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1896 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1897 * Return values: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1898 * |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1899 * -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
|
1900 * -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
|
1901 * rest: valid rev |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1902 */ |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1903 static int index_find_node(indexObject *self, const char *node, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1904 Py_ssize_t nodelen) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1905 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1906 int rev; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1907 |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
1908 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
|
1909 return -3; |
44bbc89ec5e0
revlog: remove micro-optimization for looking up only nullid
Martin von Zweigbergk <martinvonz@google.com>
parents:
38819
diff
changeset
|
1910 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1911 self->ntlookups++; |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1912 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
|
1913 if (rev >= -1) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1914 return rev; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1915 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1916 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1917 * 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
|
1918 * 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
|
1919 * 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
|
1920 * |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1921 * 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
|
1922 * 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
|
1923 * 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
|
1924 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1925 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
|
1926 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
|
1927 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
|
1928 if (n == NULL) |
37861
a9d9802d577e
revlog: don't say "not found" on internal error
Martin von Zweigbergk <martinvonz@google.com>
parents:
37860
diff
changeset
|
1929 return -3; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1930 if (memcmp(node, n, nodelen > 20 ? 20 : nodelen) == 0) { |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1931 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
|
1932 return -3; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1933 break; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1934 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1935 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1936 } else { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1937 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
|
1938 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
|
1939 if (n == NULL) |
a9d9802d577e
revlog: don't say "not found" on internal error
Martin von Zweigbergk <martinvonz@google.com>
parents:
37860
diff
changeset
|
1940 return -3; |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1941 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
|
1942 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
|
1943 return -3; |
16614
1d800eb9ba52
parsers: update ntrev when we stop scanning
Bryan O'Sullivan <bryano@fb.com>
parents:
16597
diff
changeset
|
1944 } |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1945 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
|
1946 break; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1947 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1948 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1949 self->ntrev = rev; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1950 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1951 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1952 if (rev >= 0) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1953 return rev; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1954 return -2; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1955 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1956 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1957 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
|
1958 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1959 char *node; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1960 int rev; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1961 |
40598
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
1962 if (PyInt_Check(value)) { |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
1963 long idx; |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
1964 if (!pylong_to_long(value, &idx)) { |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
1965 return NULL; |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
1966 } |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
1967 return index_get(self, idx); |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
1968 } |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1969 |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
1970 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
|
1971 return NULL; |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
1972 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
|
1973 if (rev >= -1) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1974 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
|
1975 if (rev == -2) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1976 raise_revlog_error(); |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1977 return NULL; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1978 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
1979 |
37929
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1980 /* |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1981 * 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
|
1982 */ |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1983 static int index_populate_nt(indexObject *self) |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
1984 { |
37929
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1985 int rev; |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1986 if (self->ntrev > 0) { |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1987 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
|
1988 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
|
1989 if (n == NULL) |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1990 return -1; |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
1991 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
|
1992 return -1; |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1993 } |
37930
892592475094
revlog: use literal -1 instead of variable that always has that value
Martin von Zweigbergk <martinvonz@google.com>
parents:
37929
diff
changeset
|
1994 self->ntrev = -1; |
37929
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1995 } |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1996 return 0; |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1997 } |
9c6d1d41b3e6
revlog: extract function for fully populating the radix tree
Martin von Zweigbergk <martinvonz@google.com>
parents:
37861
diff
changeset
|
1998 |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
1999 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
|
2000 { |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2001 const char *fullnode; |
42067
b01bbb8ff1f2
cext: make revlog.c PY_SSIZE_T_CLEAN
Gregory Szorc <gregory.szorc@gmail.com>
parents:
41283
diff
changeset
|
2002 Py_ssize_t nodelen; |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2003 char *node; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2004 int rev, i; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2005 |
36620
186c6df3a373
py3: bulk-replace 'const char*' format specifier passed to PyArg_ParseTuple*()
Yuya Nishihara <yuya@tcha.org>
parents:
36619
diff
changeset
|
2006 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
|
2007 return NULL; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2008 |
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
|
2009 if (nodelen < 1) { |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2010 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
|
2011 return NULL; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2012 } |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2013 |
17353
bde1185f406c
revlog: don't try to partialmatch strings those length > 40
sorcerer
parents:
17165
diff
changeset
|
2014 if (nodelen > 40) { |
bde1185f406c
revlog: don't try to partialmatch strings those length > 40
sorcerer
parents:
17165
diff
changeset
|
2015 PyErr_SetString(PyExc_ValueError, "key too long"); |
bde1185f406c
revlog: don't try to partialmatch strings those length > 40
sorcerer
parents:
17165
diff
changeset
|
2016 return NULL; |
bde1185f406c
revlog: don't try to partialmatch strings those length > 40
sorcerer
parents:
17165
diff
changeset
|
2017 } |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2018 |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2019 for (i = 0; i < nodelen; i++) |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2020 hexdigit(node, i); |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2021 if (PyErr_Occurred()) { |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2022 /* input contains non-hex characters */ |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2023 PyErr_Clear(); |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2024 Py_RETURN_NONE; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2025 } |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2026 |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
2027 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
|
2028 return NULL; |
38942
3e74c01102af
index: rename "nt_*(indexObject *self,...)" functions to "index_*"
Martin von Zweigbergk <martinvonz@google.com>
parents:
38941
diff
changeset
|
2029 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
|
2030 return NULL; |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
2031 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
|
2032 |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2033 switch (rev) { |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2034 case -4: |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2035 raise_revlog_error(); |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2036 return NULL; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2037 case -2: |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2038 Py_RETURN_NONE; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2039 case -1: |
30100
c5afe5531709
parsers: convert PyString* to PyBytes*
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30090
diff
changeset
|
2040 return PyBytes_FromStringAndSize(nullid, 20); |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2041 } |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2042 |
37860
a91f31a1e281
revlog: extract function for getting node from known-to-exist rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37858
diff
changeset
|
2043 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
|
2044 if (fullnode == NULL) { |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2045 return NULL; |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2046 } |
30100
c5afe5531709
parsers: convert PyString* to PyBytes*
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30090
diff
changeset
|
2047 return PyBytes_FromStringAndSize(fullnode, 20); |
16665
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2048 } |
e410be860393
revlog: speed up prefix matching against nodes
Bryan O'Sullivan <bryano@fb.com>
parents:
16664
diff
changeset
|
2049 |
37968
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2050 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
|
2051 { |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2052 PyObject *val; |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2053 char *node; |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2054 int length; |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2055 |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2056 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
|
2057 return NULL; |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
2058 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
|
2059 return NULL; |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2060 |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2061 self->ntlookups++; |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
2062 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
|
2063 return NULL; |
38942
3e74c01102af
index: rename "nt_*(indexObject *self,...)" functions to "index_*"
Martin von Zweigbergk <martinvonz@google.com>
parents:
38941
diff
changeset
|
2064 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
|
2065 return NULL; |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
2066 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
|
2067 if (length == -3) |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2068 return NULL; |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2069 if (length == -2) { |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2070 raise_revlog_error(); |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2071 return NULL; |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2072 } |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2073 return PyInt_FromLong(length); |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2074 } |
0304f22497fa
revlog: use node tree (native code) for shortest() calculation
Martin von Zweigbergk <martinvonz@google.com>
parents:
37930
diff
changeset
|
2075 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2076 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
|
2077 { |
16679
2950d186a927
parsers: strictly check for 20-byte hashes where they're required
Bryan O'Sullivan <bryano@fb.com>
parents:
16641
diff
changeset
|
2078 PyObject *val; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2079 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
|
2080 int rev; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2081 |
16679
2950d186a927
parsers: strictly check for 20-byte hashes where they're required
Bryan O'Sullivan <bryano@fb.com>
parents:
16641
diff
changeset
|
2082 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
|
2083 return NULL; |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
2084 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
|
2085 return NULL; |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
2086 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
|
2087 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
|
2088 return NULL; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2089 if (rev == -2) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2090 Py_RETURN_NONE; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2091 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
|
2092 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2093 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2094 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
|
2095 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2096 char *node; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2097 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2098 if (PyInt_Check(value)) { |
40598
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
2099 long rev; |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
2100 if (!pylong_to_long(value, &rev)) { |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
2101 return -1; |
fa33196088c4
revlog: replace PyInt_AS_LONG with a more portable helper function
Augie Fackler <augie@google.com>
parents:
40562
diff
changeset
|
2102 } |
38866
aa33988ad8ab
index: return False for "len(index) in index"
Martin von Zweigbergk <martinvonz@google.com>
parents:
38852
diff
changeset
|
2103 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
|
2104 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2105 |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
2106 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
|
2107 return -1; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2108 |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
2109 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
|
2110 case -3: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2111 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2112 case -2: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2113 return 0; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2114 default: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2115 return 1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2116 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2117 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2118 |
43534
0c659fc20207
index: add a `has_node` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43532
diff
changeset
|
2119 static PyObject *index_m_has_node(indexObject *self, PyObject *args) |
0c659fc20207
index: add a `has_node` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43532
diff
changeset
|
2120 { |
0c659fc20207
index: add a `has_node` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43532
diff
changeset
|
2121 int ret = index_contains(self, args); |
0c659fc20207
index: add a `has_node` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43532
diff
changeset
|
2122 if (ret < 0) |
0c659fc20207
index: add a `has_node` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43532
diff
changeset
|
2123 return NULL; |
0c659fc20207
index: add a `has_node` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43532
diff
changeset
|
2124 return PyBool_FromLong((long)ret); |
0c659fc20207
index: add a `has_node` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43532
diff
changeset
|
2125 } |
0c659fc20207
index: add a `has_node` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43532
diff
changeset
|
2126 |
43552
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2127 static PyObject *index_m_rev(indexObject *self, PyObject *val) |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2128 { |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2129 char *node; |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2130 int rev; |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2131 |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2132 if (node_check(val, &node) == -1) |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2133 return NULL; |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2134 rev = index_find_node(self, node, 20); |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2135 if (rev >= -1) |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2136 return PyInt_FromLong(rev); |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2137 if (rev == -2) |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2138 raise_revlog_error(); |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2139 return NULL; |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2140 } |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2141 |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2142 typedef uint64_t bitmask; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2143 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2144 /* |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2145 * 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
|
2146 * 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
|
2147 * "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
|
2148 */ |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2149 static PyObject *find_gca_candidates(indexObject *self, const int *revs, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2150 int revcount) |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2151 { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2152 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
|
2153 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
|
2154 PyObject *gca = PyList_New(0); |
20555
4add43865a9b
ancestors: remove unnecessary handling of 'left'
Mads Kiilerich <madski@unity3d.com>
parents:
20554
diff
changeset
|
2155 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
|
2156 int maxrev = -1; |
22399
9f490afcb067
parsers: use bitmask type consistently in find_gca_candidates
Henrik Stuart <hg@hstuart.dk>
parents:
21871
diff
changeset
|
2157 bitmask sp; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2158 bitmask *seen; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2159 |
19727
3d07b4a2f743
parsers: correctly handle a failed allocation
Bryan O'Sullivan <bryano@fb.com>
parents:
19726
diff
changeset
|
2160 if (gca == NULL) |
3d07b4a2f743
parsers: correctly handle a failed allocation
Bryan O'Sullivan <bryano@fb.com>
parents:
19726
diff
changeset
|
2161 return PyErr_NoMemory(); |
3d07b4a2f743
parsers: correctly handle a failed allocation
Bryan O'Sullivan <bryano@fb.com>
parents:
19726
diff
changeset
|
2162 |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2163 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
|
2164 if (revs[i] > maxrev) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2165 maxrev = revs[i]; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2166 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2167 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2168 seen = calloc(sizeof(*seen), maxrev + 1); |
19727
3d07b4a2f743
parsers: correctly handle a failed allocation
Bryan O'Sullivan <bryano@fb.com>
parents:
19726
diff
changeset
|
2169 if (seen == NULL) { |
3d07b4a2f743
parsers: correctly handle a failed allocation
Bryan O'Sullivan <bryano@fb.com>
parents:
19726
diff
changeset
|
2170 Py_DECREF(gca); |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2171 return PyErr_NoMemory(); |
19727
3d07b4a2f743
parsers: correctly handle a failed allocation
Bryan O'Sullivan <bryano@fb.com>
parents:
19726
diff
changeset
|
2172 } |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2173 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2174 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
|
2175 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
|
2176 |
20555
4add43865a9b
ancestors: remove unnecessary handling of 'left'
Mads Kiilerich <madski@unity3d.com>
parents:
20554
diff
changeset
|
2177 interesting = revcount; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2178 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2179 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
|
2180 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
|
2181 int parents[2]; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2182 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2183 if (!sv) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2184 continue; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2185 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2186 if (sv < poison) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2187 interesting -= 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2188 if (sv == allseen) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2189 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
|
2190 if (obj == NULL) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2191 goto bail; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2192 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
|
2193 Py_DECREF(obj); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2194 goto bail; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2195 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2196 sv |= poison; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2197 for (i = 0; i < revcount; i++) { |
20555
4add43865a9b
ancestors: remove unnecessary handling of 'left'
Mads Kiilerich <madski@unity3d.com>
parents:
20554
diff
changeset
|
2198 if (revs[i] == v) |
4add43865a9b
ancestors: remove unnecessary handling of 'left'
Mads Kiilerich <madski@unity3d.com>
parents:
20554
diff
changeset
|
2199 goto done; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2200 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2201 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2202 } |
25810
82d6a35cf432
parsers: fix buffer overflow by invalid parent revision read from revlog
Yuya Nishihara <yuya@tcha.org>
parents:
25584
diff
changeset
|
2203 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
|
2204 goto bail; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2205 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2206 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
|
2207 int p = parents[i]; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2208 if (p == -1) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2209 continue; |
19030
48d6f436363e
parsers: fix variable declaration position issue
Matt Mackall <mpm@selenic.com>
parents:
18988
diff
changeset
|
2210 sp = seen[p]; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2211 if (sv < poison) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2212 if (sp == 0) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2213 seen[p] = sv; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2214 interesting++; |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2215 } else if (sp != sv) |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2216 seen[p] |= sv; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2217 } else { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2218 if (sp && sp < poison) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2219 interesting--; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2220 seen[p] = sv; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2221 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2222 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2223 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2224 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2225 done: |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2226 free(seen); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2227 return gca; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2228 bail: |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2229 free(seen); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2230 Py_XDECREF(gca); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2231 return NULL; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2232 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2233 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2234 /* |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2235 * 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
|
2236 * path to the root. |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2237 */ |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2238 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
|
2239 { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2240 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
|
2241 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
|
2242 int *depth, *interesting = NULL; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2243 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
|
2244 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
|
2245 long *seen = NULL; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2246 int maxrev = -1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2247 long final; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2248 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2249 if (revcount > capacity) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2250 PyErr_Format(PyExc_OverflowError, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2251 "bitset size (%ld) > capacity (%ld)", |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2252 (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
|
2253 return NULL; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2254 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2255 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2256 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
|
2257 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
|
2258 if (n > maxrev) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2259 maxrev = n; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2260 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2261 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2262 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
|
2263 if (depth == NULL) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2264 return PyErr_NoMemory(); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2265 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2266 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
|
2267 if (seen == NULL) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2268 PyErr_NoMemory(); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2269 goto bail; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2270 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2271 |
39073
beab6690f202
cext: fix Windows warning about implicit conversion of 32-bit shift to 64 bit
Matt Harbison <matt_harbison@yahoo.com>
parents:
39072
diff
changeset
|
2272 interesting = calloc(sizeof(*interesting), ((size_t)1) << revcount); |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2273 if (interesting == NULL) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2274 PyErr_NoMemory(); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2275 goto bail; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2276 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2277 |
19502
8704477ad3b6
ancestor.deepest: sort revs in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19062
diff
changeset
|
2278 if (PyList_Sort(revs) == -1) |
8704477ad3b6
ancestor.deepest: sort revs in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19062
diff
changeset
|
2279 goto bail; |
8704477ad3b6
ancestor.deepest: sort revs in C version
Siddharth Agarwal <sid0@fb.com>
parents:
19062
diff
changeset
|
2280 |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2281 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
|
2282 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
|
2283 long b = 1l << i; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2284 depth[n] = 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2285 seen[n] = b; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2286 interesting[b] = 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2287 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2288 |
33475
f501322512b6
parsers: fix invariant bug in find_deepest (issue5623)
Sune Foldager <cryo@cyanite.org>
parents:
33174
diff
changeset
|
2289 /* 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
|
2290 * interesting. */ |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2291 ninteresting = (int)revcount; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2292 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2293 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
|
2294 int dv = depth[v]; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2295 int parents[2]; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2296 long sv; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2297 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2298 if (dv == 0) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2299 continue; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2300 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2301 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
|
2302 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
|
2303 goto bail; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2304 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2305 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
|
2306 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
|
2307 long sp; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2308 int dp; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2309 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2310 if (p == -1) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2311 continue; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2312 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2313 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
|
2314 sp = seen[p]; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2315 if (dp <= dv) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2316 depth[p] = dv + 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2317 if (sp != sv) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2318 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
|
2319 seen[p] = sv; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2320 if (sp) { |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2321 interesting[sp] -= 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2322 if (interesting[sp] == 0) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2323 ninteresting -= 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2324 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2325 } |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2326 } 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
|
2327 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
|
2328 if (nsp == sp) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2329 continue; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2330 seen[p] = nsp; |
19503
f2dfda6ac152
ancestor.deepest: decrement ninteresting correctly (issue3984)
Wei, Elson <elson.wei@gmail.com>
parents:
19502
diff
changeset
|
2331 interesting[sp] -= 1; |
33475
f501322512b6
parsers: fix invariant bug in find_deepest (issue5623)
Sune Foldager <cryo@cyanite.org>
parents:
33174
diff
changeset
|
2332 if (interesting[sp] == 0) |
19503
f2dfda6ac152
ancestor.deepest: decrement ninteresting correctly (issue3984)
Wei, Elson <elson.wei@gmail.com>
parents:
19502
diff
changeset
|
2333 ninteresting -= 1; |
33475
f501322512b6
parsers: fix invariant bug in find_deepest (issue5623)
Sune Foldager <cryo@cyanite.org>
parents:
33174
diff
changeset
|
2334 if (interesting[nsp] == 0) |
f501322512b6
parsers: fix invariant bug in find_deepest (issue5623)
Sune Foldager <cryo@cyanite.org>
parents:
33174
diff
changeset
|
2335 ninteresting += 1; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2336 interesting[nsp] += 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2337 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2338 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2339 interesting[sv] -= 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2340 if (interesting[sv] == 0) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2341 ninteresting -= 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2342 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2343 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2344 final = 0; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2345 j = ninteresting; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2346 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
|
2347 if (interesting[i] == 0) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2348 continue; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2349 final |= i; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2350 j -= 1; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2351 } |
21730
8da100383dc3
parsers.c: fix a couple of memory leaks
Danek Duvall <danek.duvall@oracle.com>
parents:
21103
diff
changeset
|
2352 if (final == 0) { |
8da100383dc3
parsers.c: fix a couple of memory leaks
Danek Duvall <danek.duvall@oracle.com>
parents:
21103
diff
changeset
|
2353 keys = PyList_New(0); |
8da100383dc3
parsers.c: fix a couple of memory leaks
Danek Duvall <danek.duvall@oracle.com>
parents:
21103
diff
changeset
|
2354 goto bail; |
8da100383dc3
parsers.c: fix a couple of memory leaks
Danek Duvall <danek.duvall@oracle.com>
parents:
21103
diff
changeset
|
2355 } |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2356 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2357 dict = PyDict_New(); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2358 if (dict == NULL) |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2359 goto bail; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2360 |
19504
2fa303619b4d
ancestor.deepest: ignore ninteresting while building result (issue3984)
Siddharth Agarwal <sid0@fb.com>
parents:
19503
diff
changeset
|
2361 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
|
2362 PyObject *key; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2363 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2364 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
|
2365 continue; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2366 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2367 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
|
2368 Py_INCREF(key); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2369 Py_INCREF(Py_None); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2370 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
|
2371 Py_DECREF(key); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2372 Py_DECREF(Py_None); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2373 goto bail; |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2374 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2375 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2376 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2377 keys = PyDict_Keys(dict); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2378 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2379 bail: |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2380 free(depth); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2381 free(seen); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2382 free(interesting); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2383 Py_XDECREF(dict); |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2384 |
21730
8da100383dc3
parsers.c: fix a couple of memory leaks
Danek Duvall <danek.duvall@oracle.com>
parents:
21103
diff
changeset
|
2385 return keys; |
18988
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2386 } |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2387 |
5bae936764bb
parsers: a C implementation of the new ancestors algorithm
Bryan O'Sullivan <bryano@fb.com>
parents:
18900
diff
changeset
|
2388 /* |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2389 * Given a (possibly overlapping) set of revs, return all the |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2390 * common ancestors heads: heads(::args[0] and ::a[1] and ...) |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2391 */ |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2392 static PyObject *index_commonancestorsheads(indexObject *self, PyObject *args) |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2393 { |
21103
628c16489d1c
parsers: remove unnecessary gca variable in index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
21102
diff
changeset
|
2394 PyObject *ret = NULL; |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2395 Py_ssize_t argcount, i, len; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2396 bitmask repeat = 0; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2397 int revcount = 0; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2398 int *revs; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2399 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2400 argcount = PySequence_Length(args); |
31469
a43fd9ec2a39
parsers: use Python memory allocator in commonancestorsheads()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31426
diff
changeset
|
2401 revs = PyMem_Malloc(argcount * sizeof(*revs)); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2402 if (argcount > 0 && revs == NULL) |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2403 return PyErr_NoMemory(); |
38851
781b2720d2ac
index: don't include nullid in len()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38850
diff
changeset
|
2404 len = index_length(self); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2405 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2406 for (i = 0; i < argcount; i++) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2407 static const int capacity = 24; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2408 PyObject *obj = PySequence_GetItem(args, i); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2409 bitmask x; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2410 long val; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2411 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2412 if (!PyInt_Check(obj)) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2413 PyErr_SetString(PyExc_TypeError, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2414 "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
|
2415 Py_DECREF(obj); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2416 goto bail; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2417 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2418 val = PyInt_AsLong(obj); |
23945
33d6aaf84c9e
parsers.c: fix a memory leak in index_commonancestorsheads
Augie Fackler <augie@google.com>
parents:
23944
diff
changeset
|
2419 Py_DECREF(obj); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2420 if (val == -1) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2421 ret = PyList_New(0); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2422 goto done; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2423 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2424 if (val < 0 || val >= len) { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2425 PyErr_SetString(PyExc_IndexError, "index out of range"); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2426 goto bail; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2427 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2428 /* this cheesy bloom filter lets us avoid some more |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2429 * expensive duplicate checks in the common set-is-disjoint |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2430 * case */ |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2431 x = 1ull << (val & 0x3f); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2432 if (repeat & x) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2433 int k; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2434 for (k = 0; k < revcount; k++) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2435 if (val == revs[k]) |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2436 goto duplicate; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2437 } |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2438 } else |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2439 repeat |= x; |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2440 if (revcount >= capacity) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2441 PyErr_Format(PyExc_OverflowError, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2442 "bitset size (%d) > capacity (%d)", |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2443 revcount, capacity); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2444 goto bail; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2445 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2446 revs[revcount++] = (int)val; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2447 duplicate:; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2448 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2449 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2450 if (revcount == 0) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2451 ret = PyList_New(0); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2452 goto done; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2453 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2454 if (revcount == 1) { |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2455 PyObject *obj; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2456 ret = PyList_New(1); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2457 if (ret == NULL) |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2458 goto bail; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2459 obj = PyInt_FromLong(revs[0]); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2460 if (obj == NULL) |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2461 goto bail; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2462 PyList_SET_ITEM(ret, 0, obj); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2463 goto done; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2464 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2465 |
21103
628c16489d1c
parsers: remove unnecessary gca variable in index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
21102
diff
changeset
|
2466 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
|
2467 if (ret == NULL) |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2468 goto bail; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2469 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2470 done: |
31469
a43fd9ec2a39
parsers: use Python memory allocator in commonancestorsheads()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31426
diff
changeset
|
2471 PyMem_Free(revs); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2472 return ret; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2473 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2474 bail: |
31469
a43fd9ec2a39
parsers: use Python memory allocator in commonancestorsheads()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31426
diff
changeset
|
2475 PyMem_Free(revs); |
21102
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2476 Py_XDECREF(ret); |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2477 return NULL; |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2478 } |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2479 |
4eb6553789e1
parsers: introduce index_commonancestorsheads
Mads Kiilerich <madski@unity3d.com>
parents:
20797
diff
changeset
|
2480 /* |
24004
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
2481 * 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
|
2482 * 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
|
2483 */ |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
2484 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
|
2485 { |
26048
0be2f81aadc3
parsers: fix two leaks in index_ancestors
Augie Fackler <augie@google.com>
parents:
26044
diff
changeset
|
2486 PyObject *ret; |
24004
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
2487 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
|
2488 if (gca == NULL) |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
2489 return NULL; |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
2490 |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
2491 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
|
2492 return gca; |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
2493 } |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
2494 |
26048
0be2f81aadc3
parsers: fix two leaks in index_ancestors
Augie Fackler <augie@google.com>
parents:
26044
diff
changeset
|
2495 ret = find_deepest(self, gca); |
0be2f81aadc3
parsers: fix two leaks in index_ancestors
Augie Fackler <augie@google.com>
parents:
26044
diff
changeset
|
2496 Py_DECREF(gca); |
0be2f81aadc3
parsers: fix two leaks in index_ancestors
Augie Fackler <augie@google.com>
parents:
26044
diff
changeset
|
2497 return ret; |
24004
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
2498 } |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
2499 |
8a5267cd5286
parsers: rewrite index_ancestors() in terms of index_commonancestorsheads()
Martin von Zweigbergk <martinvonz@google.com>
parents:
23948
diff
changeset
|
2500 /* |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2501 * 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
|
2502 */ |
38942
3e74c01102af
index: rename "nt_*(indexObject *self,...)" functions to "index_*"
Martin von Zweigbergk <martinvonz@google.com>
parents:
38941
diff
changeset
|
2503 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
|
2504 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2505 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
|
2506 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2507 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
|
2508 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
|
2509 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
|
2510 |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
2511 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
|
2512 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2513 |
16732
277e2acb7e5c
parsers: use Py_CLEAR where appropriate
Bryan O'Sullivan <bryano@fb.com>
parents:
16699
diff
changeset
|
2514 if (start == 0) |
277e2acb7e5c
parsers: use Py_CLEAR where appropriate
Bryan O'Sullivan <bryano@fb.com>
parents:
16699
diff
changeset
|
2515 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
|
2516 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2517 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2518 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2519 * Delete a numeric range of revs, which must be at the end of the |
43582
ae5e39512ca0
revlog: delete references to deleted nullid sentinel value
Martin von Zweigbergk <martinvonz@google.com>
parents:
43554
diff
changeset
|
2520 * range. |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2521 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2522 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
|
2523 { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2524 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
|
2525 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
|
2526 int ret = 0; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2527 |
30171
7a3b59f0329a
parsers: avoid PySliceObject cast on Python 3
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30169
diff
changeset
|
2528 /* 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
|
2529 #ifdef IS_PY3K |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2530 if (PySlice_GetIndicesEx(item, length, &start, &stop, &step, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2531 &slicelength) < 0) |
30171
7a3b59f0329a
parsers: avoid PySliceObject cast on Python 3
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30169
diff
changeset
|
2532 #else |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2533 if (PySlice_GetIndicesEx((PySliceObject *)item, length, &start, &stop, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2534 &step, &slicelength) < 0) |
30171
7a3b59f0329a
parsers: avoid PySliceObject cast on Python 3
Gregory Szorc <gregory.szorc@gmail.com>
parents:
30169
diff
changeset
|
2535 #endif |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2536 return -1; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2537 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2538 if (slicelength <= 0) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2539 return 0; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2540 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2541 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
|
2542 stop = start; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2543 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2544 if (step < 0) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2545 stop = start + 1; |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2546 start = stop + step * (slicelength - 1) - 1; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2547 step = -step; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2548 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2549 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2550 if (step != 1) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2551 PyErr_SetString(PyExc_ValueError, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2552 "revlog index delete requires step size of 1"); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2553 return -1; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2554 } |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2555 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2556 if (stop != length - 1) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2557 PyErr_SetString(PyExc_IndexError, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2558 "revlog index deletion indices are invalid"); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2559 return -1; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2560 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2561 |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
2562 if (start < self->length) { |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
2563 if (self->ntinitialized) { |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2564 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
|
2565 |
43532
53581e220ba3
revlog: clean up the node of all revision stripped in the C code
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42096
diff
changeset
|
2566 for (i = start; i < self->length; 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
|
2567 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
|
2568 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
|
2569 return -1; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2570 |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
2571 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
|
2572 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2573 if (self->added) |
38942
3e74c01102af
index: rename "nt_*(indexObject *self,...)" functions to "index_*"
Martin von Zweigbergk <martinvonz@google.com>
parents:
38941
diff
changeset
|
2574 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
|
2575 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
|
2576 self->ntrev = (int)start; |
43847
49fa0b31ee1d
cext-revlog: fixed __delitem__ for uninitialized nodetree
Georges Racinet <georges.racinet@octobus.net>
parents:
43582
diff
changeset
|
2577 } else if (self->added) { |
49fa0b31ee1d
cext-revlog: fixed __delitem__ for uninitialized nodetree
Georges Racinet <georges.racinet@octobus.net>
parents:
43582
diff
changeset
|
2578 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
|
2579 } |
43847
49fa0b31ee1d
cext-revlog: fixed __delitem__ for uninitialized nodetree
Georges Racinet <georges.racinet@octobus.net>
parents:
43582
diff
changeset
|
2580 |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
2581 self->length = start; |
18504
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
2582 if (start < self->raw_length) { |
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
2583 if (self->cache) { |
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
2584 Py_ssize_t i; |
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
2585 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
|
2586 Py_CLEAR(self->cache[i]); |
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
2587 } |
16784
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
2588 self->raw_length = start; |
18504
d1d5fdcc2d46
parsers: fix memleak of revlog cache entries on strip
Yuya Nishihara <yuya@tcha.org>
parents:
18430
diff
changeset
|
2589 } |
16784
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
2590 goto done; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2591 } |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2592 |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
2593 if (self->ntinitialized) { |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
2594 index_invalidate_added(self, start - self->length); |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2595 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
|
2596 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
|
2597 } |
16784
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
2598 if (self->added) |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
2599 ret = PyList_SetSlice(self->added, start - self->length, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2600 PyList_GET_SIZE(self->added), NULL); |
16784
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
2601 done: |
16787
bda96ce993f9
parsers: cache the result of index_headrevs
Bryan O'Sullivan <bryano@fb.com>
parents:
16786
diff
changeset
|
2602 Py_CLEAR(self->headrevs); |
16784
12a852c7c763
parsers: reduce raw_length when truncating
Bryan O'Sullivan <bryano@fb.com>
parents:
16732
diff
changeset
|
2603 return ret; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2604 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2605 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2606 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2607 * Supported ops: |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2608 * |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2609 * slice deletion |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2610 * 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
|
2611 * 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
|
2612 */ |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2613 static int index_assign_subscript(indexObject *self, PyObject *item, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2614 PyObject *value) |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2615 { |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2616 char *node; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2617 long rev; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2618 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2619 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
|
2620 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
|
2621 |
38819
49628742d264
revlog: remove unnecessary output parameter from node_check()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38305
diff
changeset
|
2622 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
|
2623 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2624 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2625 if (value == NULL) |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2626 return self->ntinitialized ? nt_delete_node(&self->nt, node) |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2627 : 0; |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2628 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
|
2629 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
|
2630 if (!PyErr_Occurred()) |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2631 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
|
2632 return -1; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2633 } |
23468
ee311681e591
parsers: ensure revlog index node tree is initialized before insertion
Mike Edgar <adgar@google.com>
parents:
23087
diff
changeset
|
2634 |
38941
c0b6a7c78a21
index: split up nt_init() in two
Martin von Zweigbergk <martinvonz@google.com>
parents:
38940
diff
changeset
|
2635 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
|
2636 return -1; |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
2637 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
|
2638 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2639 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2640 /* |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2641 * 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
|
2642 * 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
|
2643 */ |
22401
9ba8a93e55f5
parsers: ensure correct return type for inline_scan
Henrik Stuart <hg@hstuart.dk>
parents:
22400
diff
changeset
|
2644 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
|
2645 { |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2646 const char *data = (const char *)self->buf.buf; |
20167
09e41ac6289d
mpatch: rewrite pointer overflow checks
Matt Mackall <mpm@selenic.com>
parents:
20109
diff
changeset
|
2647 Py_ssize_t pos = 0; |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2648 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
|
2649 long incr = v1_hdrsize; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2650 Py_ssize_t len = 0; |
13254
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
11361
diff
changeset
|
2651 |
20167
09e41ac6289d
mpatch: rewrite pointer overflow checks
Matt Mackall <mpm@selenic.com>
parents:
20109
diff
changeset
|
2652 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
|
2653 uint32_t comp_len; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2654 /* 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
|
2655 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
|
2656 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
|
2657 if (offsets) |
20167
09e41ac6289d
mpatch: rewrite pointer overflow checks
Matt Mackall <mpm@selenic.com>
parents:
20109
diff
changeset
|
2658 offsets[len] = data + pos; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2659 len++; |
20167
09e41ac6289d
mpatch: rewrite pointer overflow checks
Matt Mackall <mpm@selenic.com>
parents:
20109
diff
changeset
|
2660 pos += incr; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2661 } |
13254
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
11361
diff
changeset
|
2662 |
20167
09e41ac6289d
mpatch: rewrite pointer overflow checks
Matt Mackall <mpm@selenic.com>
parents:
20109
diff
changeset
|
2663 if (pos != end) { |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2664 if (!PyErr_Occurred()) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2665 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
|
2666 return -1; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2667 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2668 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2669 return len; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2670 } |
13254
5ef5eb1f3515
revlog: only build the nodemap on demand
Matt Mackall <mpm@selenic.com>
parents:
11361
diff
changeset
|
2671 |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2672 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
|
2673 { |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2674 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
|
2675 Py_ssize_t size; |
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2676 |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2677 /* Initialize before argument-checking to avoid index_dealloc() crash. |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2678 */ |
20109
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
2679 self->raw_length = 0; |
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
2680 self->added = NULL; |
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
2681 self->cache = NULL; |
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
2682 self->data = NULL; |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2683 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
|
2684 self->headrevs = NULL; |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
2685 self->filteredrevs = Py_None; |
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
2686 Py_INCREF(Py_None); |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
2687 self->ntinitialized = 0; |
20109
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
2688 self->offsets = NULL; |
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
2689 |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2690 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
|
2691 return -1; |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2692 if (!PyObject_CheckBuffer(data_obj)) { |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2693 PyErr_SetString(PyExc_TypeError, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2694 "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
|
2695 return -1; |
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2696 } |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2697 |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2698 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
|
2699 return -1; |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2700 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
|
2701 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2702 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
|
2703 self->data = data_obj; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2704 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2705 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
|
2706 self->ntrev = -1; |
16597
b767382a8675
parsers: fix refcount bug on corrupt index
Matt Mackall <mpm@selenic.com>
parents:
16572
diff
changeset
|
2707 Py_INCREF(self->data); |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2708 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2709 if (self->inlined) { |
22401
9ba8a93e55f5
parsers: ensure correct return type for inline_scan
Henrik Stuart <hg@hstuart.dk>
parents:
22400
diff
changeset
|
2710 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
|
2711 if (len == -1) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2712 goto bail; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2713 self->raw_length = len; |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
2714 self->length = len; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2715 } else { |
16863
bbedef66c6f3
parsers: replace magic number 64 with symbolic constant
Bryan O'Sullivan <bryano@fb.com>
parents:
16787
diff
changeset
|
2716 if (size % v1_hdrsize) { |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2717 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
|
2718 goto bail; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2719 } |
16863
bbedef66c6f3
parsers: replace magic number 64 with symbolic constant
Bryan O'Sullivan <bryano@fb.com>
parents:
16787
diff
changeset
|
2720 self->raw_length = size / v1_hdrsize; |
39068
52e9bf215f96
index: don't include nullid in the internal "length" field
Martin von Zweigbergk <martinvonz@google.com>
parents:
38944
diff
changeset
|
2721 self->length = self->raw_length; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2722 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2723 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2724 return 0; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2725 bail: |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2726 return -1; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2727 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2728 |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2729 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
|
2730 { |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2731 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
|
2732 return (PyObject *)self; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2733 } |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2734 |
38944
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2735 static void _index_clearcaches(indexObject *self) |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2736 { |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2737 if (self->cache) { |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2738 Py_ssize_t i; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2739 |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2740 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
|
2741 Py_CLEAR(self->cache[i]); |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2742 free(self->cache); |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2743 self->cache = NULL; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2744 } |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2745 if (self->offsets) { |
39075
b935adb4b041
cext: fix a warning about differing const qualifiers on Windows
Matt Harbison <matt_harbison@yahoo.com>
parents:
39074
diff
changeset
|
2746 PyMem_Free((void *)self->offsets); |
38944
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2747 self->offsets = NULL; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2748 } |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
2749 if (self->ntinitialized) { |
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
2750 nt_dealloc(&self->nt); |
38944
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2751 } |
39291
9f097214fbf3
index: embed nodetree in index object to avoid reference cycle
Martin von Zweigbergk <martinvonz@google.com>
parents:
39228
diff
changeset
|
2752 self->ntinitialized = 0; |
38944
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2753 Py_CLEAR(self->headrevs); |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2754 } |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2755 |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2756 static PyObject *index_clearcaches(indexObject *self) |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2757 { |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2758 _index_clearcaches(self); |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2759 self->ntrev = -1; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2760 self->ntlookups = self->ntmisses = 0; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2761 Py_RETURN_NONE; |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2762 } |
c1de67691d5b
index: move index_clearcaches() further down
Martin von Zweigbergk <martinvonz@google.com>
parents:
38943
diff
changeset
|
2763 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2764 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
|
2765 { |
16370
28bb4daf070c
parsers: fix a memleak, and add a clearcaches method to the index
Bryan O'Sullivan <bryano@fb.com>
parents:
16363
diff
changeset
|
2766 _index_clearcaches(self); |
22484
2b5940f64750
obsolete: use C code for headrevs calculation
Durham Goode <durham@fb.com>
parents:
22403
diff
changeset
|
2767 Py_XDECREF(self->filteredrevs); |
30577
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2768 if (self->buf.buf) { |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2769 PyBuffer_Release(&self->buf); |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2770 memset(&self->buf, 0, sizeof(self->buf)); |
6146d5acee69
parsers: use buffer to store revlog index
Jun Wu <quark@fb.com>
parents:
30171
diff
changeset
|
2771 } |
20109
e57c532c3835
parse_index2: fix crash on bad argument type (issue4110)
Chris Jerdonek <chris.jerdonek@gmail.com>
parents:
19728
diff
changeset
|
2772 Py_XDECREF(self->data); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2773 Py_XDECREF(self->added); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2774 PyObject_Del(self); |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2775 } |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2776 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2777 static PySequenceMethods index_sequence_methods = { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2778 (lenfunc)index_length, /* sq_length */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2779 0, /* sq_concat */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2780 0, /* sq_repeat */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2781 (ssizeargfunc)index_get, /* sq_item */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2782 0, /* sq_slice */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2783 0, /* sq_ass_item */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2784 0, /* sq_ass_slice */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2785 (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
|
2786 }; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2787 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2788 static PyMappingMethods index_mapping_methods = { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2789 (lenfunc)index_length, /* mp_length */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2790 (binaryfunc)index_getitem, /* mp_subscript */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2791 (objobjargproc)index_assign_subscript, /* mp_ass_subscript */ |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2792 }; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2793 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2794 static PyMethodDef index_methods[] = { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2795 {"ancestors", (PyCFunction)index_ancestors, METH_VARARGS, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2796 "return the gca set of the given revs"}, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2797 {"commonancestorsheads", (PyCFunction)index_commonancestorsheads, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2798 METH_VARARGS, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2799 "return the heads of the common ancestors of the given revs"}, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2800 {"clearcaches", (PyCFunction)index_clearcaches, METH_NOARGS, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2801 "clear the index caches"}, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2802 {"get", (PyCFunction)index_m_get, METH_VARARGS, "get an index entry"}, |
43554
b56de57c45ce
index: add a `get_rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43552
diff
changeset
|
2803 {"get_rev", (PyCFunction)index_m_get, METH_VARARGS, |
b56de57c45ce
index: add a `get_rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43552
diff
changeset
|
2804 "return `rev` associated with a node or None"}, |
43534
0c659fc20207
index: add a `has_node` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43532
diff
changeset
|
2805 {"has_node", (PyCFunction)index_m_has_node, METH_O, |
0c659fc20207
index: add a `has_node` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43532
diff
changeset
|
2806 "return True if the node exist in the index"}, |
43552
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2807 {"rev", (PyCFunction)index_m_rev, METH_O, |
bd87114ce341
index: add a `rev` method (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43534
diff
changeset
|
2808 "return `rev` associated with a node or raise RevlogError"}, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2809 {"computephasesmapsets", (PyCFunction)compute_phases_map_sets, METH_VARARGS, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2810 "compute phases"}, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2811 {"reachableroots2", (PyCFunction)reachableroots2, METH_VARARGS, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2812 "reachableroots"}, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2813 {"headrevs", (PyCFunction)index_headrevs, METH_VARARGS, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2814 "get head revisions"}, /* Can do filtering since 3.2 */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2815 {"headrevsfiltered", (PyCFunction)index_headrevs, METH_VARARGS, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2816 "get filtered head revisions"}, /* Can always do filtering */ |
41086
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
2817 {"issnapshot", (PyCFunction)index_issnapshot, METH_O, |
a28833d79aca
revlog: use the native implementation of issnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41085
diff
changeset
|
2818 "True if the object is a snapshot"}, |
41108
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
2819 {"findsnapshots", (PyCFunction)index_findsnapshots, METH_VARARGS, |
38e88450138c
delta: have a native implementation of _findsnapshot
Boris Feld <boris.feld@octobus.net>
parents:
41086
diff
changeset
|
2820 "Gather snapshot data in a cache dict"}, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2821 {"deltachain", (PyCFunction)index_deltachain, METH_VARARGS, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2822 "determine revisions with deltas to reconstruct fulltext"}, |
40707
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
2823 {"slicechunktodensity", (PyCFunction)index_slicechunktodensity, |
cc76ca9fca20
sparse-revlog: introduce native (C) implementation of slicechunktodensity
Boris Feld <boris.feld@octobus.net>
parents:
40706
diff
changeset
|
2824 METH_VARARGS, "determine revisions with deltas to reconstruct fulltext"}, |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2825 {"append", (PyCFunction)index_append, METH_O, "append an index entry"}, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2826 {"partialmatch", (PyCFunction)index_partialmatch, METH_VARARGS, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2827 "match a potentially ambiguous node ID"}, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2828 {"shortest", (PyCFunction)index_shortest, METH_VARARGS, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2829 "find length of shortest hex nodeid of a binary ID"}, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2830 {"stats", (PyCFunction)index_stats, METH_NOARGS, "stats for the index"}, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2831 {NULL} /* Sentinel */ |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2832 }; |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2833 |
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2834 static PyGetSetDef index_getset[] = { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2835 {"nodemap", (getter)index_nodemap, NULL, "nodemap", NULL}, |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2836 {NULL} /* Sentinel */ |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2837 }; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2838 |
40860
18a8def6e1b5
revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol
Yuya Nishihara <yuya@tcha.org>
parents:
40859
diff
changeset
|
2839 PyTypeObject HgRevlogIndex_Type = { |
40562
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2840 PyVarObject_HEAD_INIT(NULL, 0) /* header */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2841 "parsers.index", /* tp_name */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2842 sizeof(indexObject), /* tp_basicsize */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2843 0, /* tp_itemsize */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2844 (destructor)index_dealloc, /* tp_dealloc */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2845 0, /* tp_print */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2846 0, /* tp_getattr */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2847 0, /* tp_setattr */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2848 0, /* tp_compare */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2849 0, /* tp_repr */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2850 0, /* tp_as_number */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2851 &index_sequence_methods, /* tp_as_sequence */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2852 &index_mapping_methods, /* tp_as_mapping */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2853 0, /* tp_hash */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2854 0, /* tp_call */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2855 0, /* tp_str */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2856 0, /* tp_getattro */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2857 0, /* tp_setattro */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2858 0, /* tp_as_buffer */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2859 Py_TPFLAGS_DEFAULT, /* tp_flags */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2860 "revlog index", /* tp_doc */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2861 0, /* tp_traverse */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2862 0, /* tp_clear */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2863 0, /* tp_richcompare */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2864 0, /* tp_weaklistoffset */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2865 0, /* tp_iter */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2866 0, /* tp_iternext */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2867 index_methods, /* tp_methods */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2868 0, /* tp_members */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2869 index_getset, /* tp_getset */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2870 0, /* tp_base */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2871 0, /* tp_dict */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2872 0, /* tp_descr_get */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2873 0, /* tp_descr_set */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2874 0, /* tp_dictoffset */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2875 (initproc)index_init, /* tp_init */ |
e5ad3ef90aa1
revlog: give formatting to clang-format
Augie Fackler <augie@google.com>
parents:
40561
diff
changeset
|
2876 0, /* tp_alloc */ |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2877 }; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2878 |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2879 /* |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2880 * 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
|
2881 * follows: |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2882 * |
16414
e8d37b78acfb
parsers: use base-16 trie for faster node->rev mapping
Bryan O'Sullivan <bryano@fb.com>
parents:
16393
diff
changeset
|
2883 * 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
|
2884 * 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
|
2885 * 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
|
2886 * |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2887 * added complications are for backwards compatibility |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2888 */ |
32378
7d0c69505a66
cext: extract revlog/index parsing code to own C file
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32372
diff
changeset
|
2889 PyObject *parse_index2(PyObject *self, PyObject *args) |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2890 { |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2891 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
|
2892 indexObject *idx; |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2893 int ret; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2894 |
40860
18a8def6e1b5
revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol
Yuya Nishihara <yuya@tcha.org>
parents:
40859
diff
changeset
|
2895 idx = PyObject_New(indexObject, &HgRevlogIndex_Type); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2896 if (idx == NULL) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2897 goto bail; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2898 |
16572
8d44b5a2974f
parsers: fix refcount leak, simplify init of index (issue3417)
Bryan O'Sullivan <bryano@fb.com>
parents:
16437
diff
changeset
|
2899 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
|
2900 if (ret == -1) |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2901 goto bail; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2902 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2903 if (idx->inlined) { |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2904 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
|
2905 if (cache == NULL) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2906 goto bail; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2907 } else { |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2908 cache = Py_None; |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2909 Py_INCREF(cache); |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2910 } |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2911 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2912 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
|
2913 if (!tuple) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2914 goto bail; |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2915 return tuple; |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2916 |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2917 bail: |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2918 Py_XDECREF(idx); |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2919 Py_XDECREF(cache); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2920 Py_XDECREF(tuple); |
7108
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2921 return NULL; |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2922 } |
1ca878d7b849
C implementation of revlog index parsing
Bernhard Leiner <bleiner@gmail.com>
parents:
7093
diff
changeset
|
2923 |
43959
f384d68d8ea8
revlog: made C Capsule an array of function pointers
Georges Racinet <georges.racinet@octobus.net>
parents:
43847
diff
changeset
|
2924 static Revlog_CAPI CAPI = { |
44066
f5d2720f3bea
revlog-native: introduced ABI version in capsule
Georges Racinet <georges.racinet@octobus.net>
parents:
43959
diff
changeset
|
2925 /* increment the abi_version field upon each change in the Revlog_CAPI |
f5d2720f3bea
revlog-native: introduced ABI version in capsule
Georges Racinet <georges.racinet@octobus.net>
parents:
43959
diff
changeset
|
2926 struct or in the ABI of the listed functions */ |
44502
166349510398
revlog: using two new functions in C capsule from Rust code
Georges Racinet <georges.racinet@octobus.net>
parents:
44486
diff
changeset
|
2927 2, |
166349510398
revlog: using two new functions in C capsule from Rust code
Georges Racinet <georges.racinet@octobus.net>
parents:
44486
diff
changeset
|
2928 index_length, |
166349510398
revlog: using two new functions in C capsule from Rust code
Georges Racinet <georges.racinet@octobus.net>
parents:
44486
diff
changeset
|
2929 index_node, |
43959
f384d68d8ea8
revlog: made C Capsule an array of function pointers
Georges Racinet <georges.racinet@octobus.net>
parents:
43847
diff
changeset
|
2930 HgRevlogIndex_GetParents, |
f384d68d8ea8
revlog: made C Capsule an array of function pointers
Georges Racinet <georges.racinet@octobus.net>
parents:
43847
diff
changeset
|
2931 }; |
f384d68d8ea8
revlog: made C Capsule an array of function pointers
Georges Racinet <georges.racinet@octobus.net>
parents:
43847
diff
changeset
|
2932 |
32378
7d0c69505a66
cext: extract revlog/index parsing code to own C file
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32372
diff
changeset
|
2933 void revlog_module_init(PyObject *mod) |
24017
72c9b5ae7278
parsers: add fm1readmarker
Augie Fackler <augie@google.com>
parents:
24004
diff
changeset
|
2934 { |
41052
4c25038c112c
rust-cpython: implement Graph using C parents function
Georges Racinet <gracinet@anybox.fr>
parents:
40963
diff
changeset
|
2935 PyObject *caps = NULL; |
40860
18a8def6e1b5
revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol
Yuya Nishihara <yuya@tcha.org>
parents:
40859
diff
changeset
|
2936 HgRevlogIndex_Type.tp_new = PyType_GenericNew; |
18a8def6e1b5
revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol
Yuya Nishihara <yuya@tcha.org>
parents:
40859
diff
changeset
|
2937 if (PyType_Ready(&HgRevlogIndex_Type) < 0) |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2938 return; |
40860
18a8def6e1b5
revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol
Yuya Nishihara <yuya@tcha.org>
parents:
40859
diff
changeset
|
2939 Py_INCREF(&HgRevlogIndex_Type); |
18a8def6e1b5
revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol
Yuya Nishihara <yuya@tcha.org>
parents:
40859
diff
changeset
|
2940 PyModule_AddObject(mod, "index", (PyObject *)&HgRevlogIndex_Type); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2941 |
39218
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
2942 nodetreeType.tp_new = PyType_GenericNew; |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
2943 if (PyType_Ready(&nodetreeType) < 0) |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
2944 return; |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
2945 Py_INCREF(&nodetreeType); |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
2946 PyModule_AddObject(mod, "nodetree", (PyObject *)&nodetreeType); |
b85b377e7fc2
index: make node tree a Python object
Martin von Zweigbergk <martinvonz@google.com>
parents:
39075
diff
changeset
|
2947 |
40088
129bfc7ad2cc
revlog: if the module is initialized more than once, don't leak nullentry
Augie Fackler <augie@google.com>
parents:
39609
diff
changeset
|
2948 if (!nullentry) { |
42096
509a0477b3a6
cext: cast s# arguments of Py_BuildValue() to Py_ssize_t
Yuya Nishihara <yuya@tcha.org>
parents:
42067
diff
changeset
|
2949 nullentry = |
509a0477b3a6
cext: cast s# arguments of Py_BuildValue() to Py_ssize_t
Yuya Nishihara <yuya@tcha.org>
parents:
42067
diff
changeset
|
2950 Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0, 0, -1, |
509a0477b3a6
cext: cast s# arguments of Py_BuildValue() to Py_ssize_t
Yuya Nishihara <yuya@tcha.org>
parents:
42067
diff
changeset
|
2951 -1, -1, -1, nullid, (Py_ssize_t)20); |
40088
129bfc7ad2cc
revlog: if the module is initialized more than once, don't leak nullentry
Augie Fackler <augie@google.com>
parents:
39609
diff
changeset
|
2952 } |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2953 if (nullentry) |
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2954 PyObject_GC_UnTrack(nullentry); |
40273
3b275f549777
rust: exposing in parsers module
Georges Racinet <gracinet@anybox.fr>
parents:
40099
diff
changeset
|
2955 |
43959
f384d68d8ea8
revlog: made C Capsule an array of function pointers
Georges Racinet <georges.racinet@octobus.net>
parents:
43847
diff
changeset
|
2956 caps = PyCapsule_New(&CAPI, "mercurial.cext.parsers.revlog_CAPI", NULL); |
41052
4c25038c112c
rust-cpython: implement Graph using C parents function
Georges Racinet <gracinet@anybox.fr>
parents:
40963
diff
changeset
|
2957 if (caps != NULL) |
43959
f384d68d8ea8
revlog: made C Capsule an array of function pointers
Georges Racinet <georges.racinet@octobus.net>
parents:
43847
diff
changeset
|
2958 PyModule_AddObject(mod, "revlog_CAPI", caps); |
16363
2cdd7e63211b
parsers: incrementally parse the revlog index in C
Bryan O'Sullivan <bryano@fb.com>
parents:
15033
diff
changeset
|
2959 } |