This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9450

cext: isolate hash size in the revlog handling in a single place
ClosedPublic

Authored by joerg.sonnenberger on Nov 28 2020, 5:39 PM.

Details

Reviewers
Alphare
martinvonz
Group Reviewers
hg-reviewers
Commits
rHG41733a1c3532: cext: isolate hash size in the revlog handling in a single place

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

Alphare accepted this revision.Dec 7 2020, 5:18 AM
martinvonz requested changes to this revision.Dec 16 2020, 6:31 PM
martinvonz added a subscriber: martinvonz.
martinvonz added inline comments.
mercurial/cext/revlog.c
1500

Is this extra node[1] == '\0' check intentional? It seems unrelated to me. Can you move it to a separate patch?

This revision now requires changes to proceed.Dec 16 2020, 6:31 PM
joerg.sonnenberger added inline comments.Dec 16 2020, 6:56 PM
mercurial/cext/revlog.c
1500

Yes, it is intentional. I've added it because unlike before, the memcmp will not be inlined automatically and therefore the original check does come with a much higher false positive rate. The explicit check is for free on all architectures with unaligned memory access.

martinvonz added inline comments.Dec 16 2020, 6:59 PM
mercurial/cext/revlog.c
1500

Okay, makes sense. That was far from obvious (to me anyway) and could probably have been mentioned in the commit message.

martinvonz accepted this revision.Dec 16 2020, 9:08 PM
This revision is now accepted and ready to land.Dec 16 2020, 9:08 PM
martinvonz added a comment.Dec 17 2020, 11:37 AM

Can you send a followup for this warning?

mercurial/cext/revlog.c: In function 'index_init':
mercurial/cext/revlog.c:2615:42: warning: comparison of integer expressions of different signedness: 'Py_ssize_t' {aka 'long int'} and 'long unsigned int' [-Wsign-compare]
 2615 |  if (self->nodelen < 20 || self->nodelen > sizeof(nullid)) {
      |                                          ^

Revision Contents
Changeset List

PathPackages
Mmercurial/cext/revlog.c (115 lines)

Diff 24343

mercurial/cext/revlog.c

* *
* Positive value is index of the next node in the trie * Positive value is index of the next node in the trie
* Negative value is a leaf: -(rev + 2) * Negative value is a leaf: -(rev + 2)
* Zero is empty * Zero is empty
*/ */
typedef struct { typedef struct {
indexObject *index; indexObject *index;
nodetreenode *nodes; nodetreenode *nodes;
Py_ssize_t nodelen;
unsigned length; /* # nodes in use */ unsigned length; /* # nodes in use */
unsigned capacity; /* # nodes allocated */ unsigned capacity; /* # nodes allocated */
int depth; /* maximum depth of tree */ int depth; /* maximum depth of tree */
int splits; /* # splits performed */ int splits; /* # splits performed */
} nodetree; } nodetree;
typedef struct { typedef struct {
PyObject_HEAD /* ; */ PyObject_HEAD /* ; */
* *
* With string keys, we lazily perform a reverse mapping from node to * With string keys, we lazily perform a reverse mapping from node to
* rev, using a base-16 trie. * rev, using a base-16 trie.
*/ */
struct indexObjectStruct { struct indexObjectStruct {
PyObject_HEAD PyObject_HEAD
/* Type-specific fields go here. */ /* Type-specific fields go here. */
PyObject *data; /* raw bytes of index */ PyObject *data; /* raw bytes of index */
Py_ssize_t nodelen; /* digest size of the hash, 20 for SHA-1 */
PyObject *nullentry; /* fast path for references to null */
Py_buffer buf; /* buffer of data */ Py_buffer buf; /* buffer of data */
const char **offsets; /* populated on demand */ const char **offsets; /* populated on demand */
Py_ssize_t length; /* current on-disk number of elements */ Py_ssize_t length; /* current on-disk number of elements */
unsigned new_length; /* number of added elements */ unsigned new_length; /* number of added elements */
unsigned added_length; /* space reserved for added elements */ unsigned added_length; /* space reserved for added elements */
char *added; /* populated on demand */ char *added; /* populated on demand */
PyObject *headrevs; /* cache, invalidated on changes */ PyObject *headrevs; /* cache, invalidated on changes */
PyObject *filteredrevs; /* filtered revs set */ PyObject *filteredrevs; /* filtered revs set */
nodetree nt; /* base-16 trie */ nodetree nt; /* base-16 trie */
int ntinitialized; /* 0 or 1 */ int ntinitialized; /* 0 or 1 */
int ntrev; /* last rev scanned */ int ntrev; /* last rev scanned */
int ntlookups; /* # lookups */ int ntlookups; /* # lookups */
int ntmisses; /* # lookups that miss the cache */ int ntmisses; /* # lookups that miss the cache */
int inlined; int inlined;
}; };
static Py_ssize_t index_length(const indexObject *self) static Py_ssize_t index_length(const indexObject *self)
{ {
return self->length + self->new_length; return self->length + self->new_length;
} }
static PyObject *nullentry = NULL; static const char nullid[32] = {0};
static const char nullid[20] = {0};
static const Py_ssize_t nullrev = -1; static const Py_ssize_t nullrev = -1;
static Py_ssize_t inline_scan(indexObject *self, const char **offsets); static Py_ssize_t inline_scan(indexObject *self, const char **offsets);
static int index_find_node(indexObject *self, const char *node, static int index_find_node(indexObject *self, const char *node);
Py_ssize_t nodelen);
#if LONG_MAX == 0x7fffffffL #if LONG_MAX == 0x7fffffffL
static const char *const tuple_format = PY23("Kiiiiiis#", "Kiiiiiiy#"); static const char *const tuple_format = PY23("Kiiiiiis#", "Kiiiiiiy#");
#else #else
static const char *const tuple_format = PY23("kiiiiiis#", "kiiiiiiy#"); static const char *const tuple_format = PY23("kiiiiiis#", "kiiiiiiy#");
#endif #endif
/* A RevlogNG v1 index entry is 64 bytes long. */ /* A RevlogNG v1 index entry is 64 bytes long. */
* 6 bytes: offset * 6 bytes: offset
* 2 bytes: flags * 2 bytes: flags
* 4 bytes: compressed length * 4 bytes: compressed length
* 4 bytes: uncompressed length * 4 bytes: uncompressed length
* 4 bytes: base revision * 4 bytes: base revision
* 4 bytes: link revision * 4 bytes: link revision
* 4 bytes: parent 1 revision * 4 bytes: parent 1 revision
* 4 bytes: parent 2 revision * 4 bytes: parent 2 revision
* 32 bytes: nodeid (only 20 bytes used) * 32 bytes: nodeid (only 20 bytes used with SHA-1)
*/ */
static PyObject *index_get(indexObject *self, Py_ssize_t pos) static PyObject *index_get(indexObject *self, Py_ssize_t pos)
{ {
uint64_t offset_flags; uint64_t offset_flags;
int comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2; int comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2;
const char *c_node_id; const char *c_node_id;
const char *data; const char *data;
Py_ssize_t length = index_length(self); Py_ssize_t length = index_length(self);
if (pos == nullrev) { if (pos == nullrev) {
Py_INCREF(nullentry); Py_INCREF(self->nullentry);
return nullentry; return self->nullentry;
} }
if (pos < 0 || pos >= length) { if (pos < 0 || pos >= length) {
PyErr_SetString(PyExc_IndexError, "revlog index out of range"); PyErr_SetString(PyExc_IndexError, "revlog index out of range");
return NULL; return NULL;
} }
data = index_deref(self, pos); data = index_deref(self, pos);
base_rev = getbe32(data + 16); base_rev = getbe32(data + 16);
link_rev = getbe32(data + 20); link_rev = getbe32(data + 20);
parent_1 = getbe32(data + 24); parent_1 = getbe32(data + 24);
parent_2 = getbe32(data + 28); parent_2 = getbe32(data + 28);
c_node_id = data + 32; c_node_id = data + 32;
return Py_BuildValue(tuple_format, offset_flags, comp_len, uncomp_len, return Py_BuildValue(tuple_format, offset_flags, comp_len, uncomp_len,
base_rev, link_rev, parent_1, parent_2, c_node_id, base_rev, link_rev, parent_1, parent_2, c_node_id,
(Py_ssize_t)20); self->nodelen);
} }
/* /*
* Return the 20-byte SHA of the node corresponding to the given rev. * Return the hash of node corresponding to the given rev.
*/ */
static const char *index_node(indexObject *self, Py_ssize_t pos) static const char *index_node(indexObject *self, Py_ssize_t pos)
{ {
Py_ssize_t length = index_length(self); Py_ssize_t length = index_length(self);
const char *data; const char *data;
if (pos == nullrev) if (pos == nullrev)
return nullid; return nullid;
if (pos >= length) if (pos >= length)
return NULL; return NULL;
data = index_deref(self, pos); data = index_deref(self, pos);
return data ? data + 32 : NULL; return data ? data + 32 : NULL;
} }
/* /*
* Return the 20-byte SHA of the node corresponding to the given rev. The * Return the hash of the node corresponding to the given rev. The
* rev is assumed to be existing. If not, an exception is set. * rev is assumed to be existing. If not, an exception is set.
*/ */
static const char *index_node_existing(indexObject *self, Py_ssize_t pos) static const char *index_node_existing(indexObject *self, Py_ssize_t pos)
{ {
const char *node = index_node(self, pos); const char *node = index_node(self, pos);
if (node == NULL) { if (node == NULL) {
PyErr_Format(PyExc_IndexError, "could not access rev %d", PyErr_Format(PyExc_IndexError, "could not access rev %d",
(int)pos); (int)pos);
} }
return node; return node;
} }
static int nt_insert(nodetree *self, const char *node, int rev); static int nt_insert(nodetree *self, const char *node, int rev);
static int node_check(PyObject *obj, char **node) static int node_check(Py_ssize_t nodelen, PyObject *obj, char **node)
{ {
Py_ssize_t nodelen; Py_ssize_t thisnodelen;
if (PyBytes_AsStringAndSize(obj, node, &nodelen) == -1) if (PyBytes_AsStringAndSize(obj, node, &thisnodelen) == -1)
return -1; return -1;
if (nodelen == 20) if (nodelen == thisnodelen)
return 0; return 0;
PyErr_SetString(PyExc_ValueError, "20-byte hash required"); PyErr_Format(PyExc_ValueError, "node len %zd != expected node len %zd",
thisnodelen, nodelen);
return -1; return -1;
} }
static PyObject *index_append(indexObject *self, PyObject *obj) static PyObject *index_append(indexObject *self, PyObject *obj)
{ {
uint64_t offset_flags; uint64_t offset_flags;
int rev, comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2; int rev, comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2;
Py_ssize_t c_node_id_len; Py_ssize_t c_node_id_len;
const char *c_node_id; const char *c_node_id;
char *data; char *data;
if (!PyArg_ParseTuple(obj, tuple_format, &offset_flags, &comp_len, if (!PyArg_ParseTuple(obj, tuple_format, &offset_flags, &comp_len,
&uncomp_len, &base_rev, &link_rev, &parent_1, &uncomp_len, &base_rev, &link_rev, &parent_1,
&parent_2, &c_node_id, &c_node_id_len)) { &parent_2, &c_node_id, &c_node_id_len)) {
PyErr_SetString(PyExc_TypeError, "8-tuple required"); PyErr_SetString(PyExc_TypeError, "8-tuple required");
return NULL; return NULL;
} }
if (c_node_id_len != 20 && c_node_id_len != 32) { if (c_node_id_len != self->nodelen) {
PyErr_SetString(PyExc_TypeError, "invalid node"); PyErr_SetString(PyExc_TypeError, "invalid node");
return NULL; return NULL;
} }
if (self->new_length == self->added_length) { if (self->new_length == self->added_length) {
size_t new_added_length = size_t new_added_length =
self->added_length ? self->added_length * 2 : 4096; self->added_length ? self->added_length * 2 : 4096;
void *new_added = void *new_added =
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"roots must be a set of nodes"); "roots must be a set of nodes");
return -2; return -2;
} }
iterator = PyObject_GetIter(roots); iterator = PyObject_GetIter(roots);
if (iterator == NULL) if (iterator == NULL)
return -2; return -2;
while ((item = PyIter_Next(iterator))) { while ((item = PyIter_Next(iterator))) {
if (node_check(item, &node) == -1) if (node_check(self->nodelen, item, &node) == -1)
goto failed; goto failed;
rev = index_find_node(self, node, 20); rev = index_find_node(self, node);
/* null is implicitly public, so negative is invalid */ /* null is implicitly public, so negative is invalid */
if (rev < 0 || rev >= len) if (rev < 0 || rev >= len)
goto failed; goto failed;
phases[rev] = phase; phases[rev] = phase;
if (minrev == -1 || minrev > rev) if (minrev == -1 || minrev > rev)
minrev = rev; minrev = rev;
Py_DECREF(item); Py_DECREF(item);
} }
* rest: valid rev * rest: valid rev
*/ */
static int nt_find(nodetree *self, const char *node, Py_ssize_t nodelen, static int nt_find(nodetree *self, const char *node, Py_ssize_t nodelen,
int hex) int hex)
{ {
int (*getnybble)(const char *, Py_ssize_t) = hex ? hexdigit : nt_level; int (*getnybble)(const char *, Py_ssize_t) = hex ? hexdigit : nt_level;
int level, maxlevel, off; int level, maxlevel, off;
if (nodelen == 20 && node[0] == '\0' && memcmp(node, nullid, 20) == 0) /* If the input is binary, do a fast check for the nullid first. */
if (!hex && nodelen == self->nodelen && node[0] == '\0' &&
node[1] == '\0' && memcmp(node, nullid, self->nodelen) == 0)
martinvonzUnsubmitted
Not Done

Is this extra node[1] == '\0' check intentional? It seems unrelated to me. Can you move it to a separate patch?

martinvonz: Is this extra `node[1] == '\0'` check intentional? It seems unrelated to me. Can you move it to…
joerg.sonnenbergerAuthorUnsubmitted
Not Done

Yes, it is intentional. I've added it because unlike before, the memcmp will not be inlined automatically and therefore the original check does come with a much higher false positive rate. The explicit check is for free on all architectures with unaligned memory access.

joerg.sonnenberger: Yes, it is intentional. I've added it because unlike before, the memcmp will not be inlined…
martinvonzUnsubmitted
Not Done

Okay, makes sense. That was far from obvious (to me anyway) and could probably have been mentioned in the commit message.

martinvonz: Okay, makes sense. That was far from obvious (to me anyway) and could probably have been…
return -1; return -1;
if (hex) if (hex)
maxlevel = nodelen > 40 ? 40 : (int)nodelen; maxlevel = nodelen;
else else
maxlevel = nodelen > 20 ? 40 : ((int)nodelen * 2); maxlevel = 2 * nodelen;
if (maxlevel > 2 * self->nodelen)
maxlevel = 2 * self->nodelen;
for (level = off = 0; level < maxlevel; level++) { for (level = off = 0; level < maxlevel; level++) {
int k = getnybble(node, level); int k = getnybble(node, level);
nodetreenode *n = &self->nodes[off]; nodetreenode *n = &self->nodes[off];
int v = n->children[k]; int v = n->children[k];
if (v < 0) { if (v < 0) {
const char *n; const char *n;
return self->length++; return self->length++;
} }
static int nt_insert(nodetree *self, const char *node, int rev) static int nt_insert(nodetree *self, const char *node, int rev)
{ {
int level = 0; int level = 0;
int off = 0; int off = 0;
while (level < 40) { while (level < 2 * self->nodelen) {
int k = nt_level(node, level); int k = nt_level(node, level);
nodetreenode *n; nodetreenode *n;
int v; int v;
n = &self->nodes[off]; n = &self->nodes[off];
v = n->children[k]; v = n->children[k];
if (v == 0) { if (v == 0) {
n->children[k] = -rev - 2; n->children[k] = -rev - 2;
return 0; return 0;
} }
if (v < 0) { if (v < 0) {
const char *oldnode = const char *oldnode =
index_node_existing(self->index, -(v + 2)); index_node_existing(self->index, -(v + 2));
int noff; int noff;
if (oldnode == NULL) if (oldnode == NULL)
return -1; return -1;
if (!memcmp(oldnode, node, 20)) { if (!memcmp(oldnode, node, self->nodelen)) {
n->children[k] = -rev - 2; n->children[k] = -rev - 2;
return 0; return 0;
} }
noff = nt_new(self); noff = nt_new(self);
if (noff == -1) if (noff == -1)
return -1; return -1;
/* self->nodes may have been changed by realloc */ /* self->nodes may have been changed by realloc */
self->nodes[off].children[k] = noff; self->nodes[off].children[k] = noff;
{ {
/* Initialize before overflow-checking to avoid nt_dealloc() crash. */ /* Initialize before overflow-checking to avoid nt_dealloc() crash. */
self->nodes = NULL; self->nodes = NULL;
self->index = index; self->index = index;
/* The input capacity is in terms of revisions, while the field is in /* The input capacity is in terms of revisions, while the field is in
* terms of nodetree nodes. */ * terms of nodetree nodes. */
self->capacity = (capacity < 4 ? 4 : capacity / 2); self->capacity = (capacity < 4 ? 4 : capacity / 2);
self->nodelen = index->nodelen;
self->depth = 0; self->depth = 0;
self->splits = 0; self->splits = 0;
if ((size_t)self->capacity > INT_MAX / sizeof(nodetreenode)) { if ((size_t)self->capacity > INT_MAX / sizeof(nodetreenode)) {
PyErr_SetString(PyExc_ValueError, "overflow in init_nt"); PyErr_SetString(PyExc_ValueError, "overflow in init_nt");
return -1; return -1;
} }
self->nodes = calloc(self->capacity, sizeof(nodetreenode)); self->nodes = calloc(self->capacity, sizeof(nodetreenode));
if (self->nodes == NULL) { if (self->nodes == NULL) {
* -3: error (exception set) * -3: error (exception set)
* -2: not found (no exception set) * -2: not found (no exception set)
* rest: length of shortest prefix * rest: length of shortest prefix
*/ */
static int nt_shortest(nodetree *self, const char *node) static int nt_shortest(nodetree *self, const char *node)
{ {
int level, off; int level, off;
for (level = off = 0; level < 40; level++) { for (level = off = 0; level < 2 * self->nodelen; level++) {
int k, v; int k, v;
nodetreenode *n = &self->nodes[off]; nodetreenode *n = &self->nodes[off];
k = nt_level(node, level); k = nt_level(node, level);
v = n->children[k]; v = n->children[k];
if (v < 0) { if (v < 0) {
const char *n; const char *n;
v = -(v + 2); v = -(v + 2);
n = index_node_existing(self->index, v); n = index_node_existing(self->index, v);
if (n == NULL) if (n == NULL)
return -3; return -3;
if (memcmp(node, n, 20) != 0) if (memcmp(node, n, self->nodelen) != 0)
/* /*
* Found a unique prefix, but it wasn't for the * Found a unique prefix, but it wasn't for the
* requested node (i.e the requested node does * requested node (i.e the requested node does
* not exist). * not exist).
*/ */
return -2; return -2;
return level + 1; return level + 1;
} }
static PyObject *ntobj_shortest(nodetreeObject *self, PyObject *args) static PyObject *ntobj_shortest(nodetreeObject *self, PyObject *args)
{ {
PyObject *val; PyObject *val;
char *node; char *node;
int length; int length;
if (!PyArg_ParseTuple(args, "O", &val)) if (!PyArg_ParseTuple(args, "O", &val))
return NULL; return NULL;
if (node_check(val, &node) == -1) if (node_check(self->nt.nodelen, val, &node) == -1)
return NULL; return NULL;
length = nt_shortest(&self->nt, node); length = nt_shortest(&self->nt, node);
if (length == -3) if (length == -3)
return NULL; return NULL;
if (length == -2) { if (length == -2) {
raise_revlog_error(); raise_revlog_error();
return NULL; return NULL;
/* /*
* Return values: * Return values:
* *
* -3: error (exception set) * -3: error (exception set)
* -2: not found (no exception set) * -2: not found (no exception set)
* rest: valid rev * rest: valid rev
*/ */
static int index_find_node(indexObject *self, const char *node, static int index_find_node(indexObject *self, const char *node)
Py_ssize_t nodelen)
{ {
int rev; int rev;
if (index_init_nt(self) == -1) if (index_init_nt(self) == -1)
return -3; return -3;
self->ntlookups++; self->ntlookups++;
rev = nt_find(&self->nt, node, nodelen, 0); rev = nt_find(&self->nt, node, self->nodelen, 0);
if (rev >= -1) if (rev >= -1)
return rev; return rev;
/* /*
* For the first handful of lookups, we scan the entire index, * For the first handful of lookups, we scan the entire index,
* and cache only the matching nodes. This optimizes for cases * and cache only the matching nodes. This optimizes for cases
* like "hg tip", where only a few nodes are accessed. * like "hg tip", where only a few nodes are accessed.
* *
* After that, we cache every node we visit, using a single * After that, we cache every node we visit, using a single
* scan amortized over multiple lookups. This gives the best * scan amortized over multiple lookups. This gives the best
* bulk performance, e.g. for "hg log". * bulk performance, e.g. for "hg log".
*/ */
if (self->ntmisses++ < 4) { if (self->ntmisses++ < 4) {
for (rev = self->ntrev - 1; rev >= 0; rev--) { for (rev = self->ntrev - 1; rev >= 0; rev--) {
const char *n = index_node_existing(self, rev); const char *n = index_node_existing(self, rev);
if (n == NULL) if (n == NULL)
return -3; return -3;
if (memcmp(node, n, nodelen > 20 ? 20 : nodelen) == 0) { if (memcmp(node, n, self->nodelen) == 0) {
if (nt_insert(&self->nt, n, rev) == -1) if (nt_insert(&self->nt, n, rev) == -1)
return -3; return -3;
break; break;
} }
} }
} else { } else {
for (rev = self->ntrev - 1; rev >= 0; rev--) { for (rev = self->ntrev - 1; rev >= 0; rev--) {
const char *n = index_node_existing(self, rev); const char *n = index_node_existing(self, rev);
if (n == NULL) if (n == NULL)
return -3; return -3;
if (nt_insert(&self->nt, n, rev) == -1) { if (nt_insert(&self->nt, n, rev) == -1) {
self->ntrev = rev + 1; self->ntrev = rev + 1;
return -3; return -3;
} }
if (memcmp(node, n, nodelen > 20 ? 20 : nodelen) == 0) { if (memcmp(node, n, self->nodelen) == 0) {
break; break;
} }
} }
self->ntrev = rev; self->ntrev = rev;
} }
if (rev >= 0) if (rev >= 0)
return rev; return rev;
return -2; return -2;
} }
static PyObject *index_getitem(indexObject *self, PyObject *value) static PyObject *index_getitem(indexObject *self, PyObject *value)
{ {
char *node; char *node;
int rev; int rev;
if (PyInt_Check(value)) { if (PyInt_Check(value)) {
long idx; long idx;
if (!pylong_to_long(value, &idx)) { if (!pylong_to_long(value, &idx)) {
return NULL; return NULL;
} }
return index_get(self, idx); return index_get(self, idx);
} }
if (node_check(value, &node) == -1) if (node_check(self->nodelen, value, &node) == -1)
return NULL; return NULL;
rev = index_find_node(self, node, 20); rev = index_find_node(self, node);
if (rev >= -1) if (rev >= -1)
return PyInt_FromLong(rev); return PyInt_FromLong(rev);
if (rev == -2) if (rev == -2)
raise_revlog_error(); raise_revlog_error();
return NULL; return NULL;
} }
/* /*
if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &node, &nodelen)) if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &node, &nodelen))
return NULL; return NULL;
if (nodelen < 1) { if (nodelen < 1) {
PyErr_SetString(PyExc_ValueError, "key too short"); PyErr_SetString(PyExc_ValueError, "key too short");
return NULL; return NULL;
} }
if (nodelen > 40) { if (nodelen > 2 * self->nodelen) {
PyErr_SetString(PyExc_ValueError, "key too long"); PyErr_SetString(PyExc_ValueError, "key too long");
return NULL; return NULL;
} }
for (i = 0; i < nodelen; i++) for (i = 0; i < nodelen; i++)
hexdigit(node, i); hexdigit(node, i);
if (PyErr_Occurred()) { if (PyErr_Occurred()) {
/* input contains non-hex characters */ /* input contains non-hex characters */
switch (rev) { switch (rev) {
case -4: case -4:
raise_revlog_error(); raise_revlog_error();
return NULL; return NULL;
case -2: case -2:
Py_RETURN_NONE; Py_RETURN_NONE;
case -1: case -1:
return PyBytes_FromStringAndSize(nullid, 20); return PyBytes_FromStringAndSize(nullid, self->nodelen);
} }
fullnode = index_node_existing(self, rev); fullnode = index_node_existing(self, rev);
if (fullnode == NULL) { if (fullnode == NULL) {
return NULL; return NULL;
} }
return PyBytes_FromStringAndSize(fullnode, 20); return PyBytes_FromStringAndSize(fullnode, self->nodelen);
} }
static PyObject *index_shortest(indexObject *self, PyObject *args) static PyObject *index_shortest(indexObject *self, PyObject *args)
{ {
PyObject *val; PyObject *val;
char *node; char *node;
int length; int length;
if (!PyArg_ParseTuple(args, "O", &val)) if (!PyArg_ParseTuple(args, "O", &val))
return NULL; return NULL;
if (node_check(val, &node) == -1) if (node_check(self->nodelen, val, &node) == -1)
return NULL; return NULL;
self->ntlookups++; self->ntlookups++;
if (index_init_nt(self) == -1) if (index_init_nt(self) == -1)
return NULL; return NULL;
if (index_populate_nt(self) == -1) if (index_populate_nt(self) == -1)
return NULL; return NULL;
length = nt_shortest(&self->nt, node); length = nt_shortest(&self->nt, node);
static PyObject *index_m_get(indexObject *self, PyObject *args) static PyObject *index_m_get(indexObject *self, PyObject *args)
{ {
PyObject *val; PyObject *val;
char *node; char *node;
int rev; int rev;
if (!PyArg_ParseTuple(args, "O", &val)) if (!PyArg_ParseTuple(args, "O", &val))
return NULL; return NULL;
if (node_check(val, &node) == -1) if (node_check(self->nodelen, val, &node) == -1)
return NULL; return NULL;
rev = index_find_node(self, node, 20); rev = index_find_node(self, node);
if (rev == -3) if (rev == -3)
return NULL; return NULL;
if (rev == -2) if (rev == -2)
Py_RETURN_NONE; Py_RETURN_NONE;
return PyInt_FromLong(rev); return PyInt_FromLong(rev);
} }
static int index_contains(indexObject *self, PyObject *value) static int index_contains(indexObject *self, PyObject *value)
{ {
char *node; char *node;
if (PyInt_Check(value)) { if (PyInt_Check(value)) {
long rev; long rev;
if (!pylong_to_long(value, &rev)) { if (!pylong_to_long(value, &rev)) {
return -1; return -1;
} }
return rev >= -1 && rev < index_length(self); return rev >= -1 && rev < index_length(self);
} }
if (node_check(value, &node) == -1) if (node_check(self->nodelen, value, &node) == -1)
return -1; return -1;
switch (index_find_node(self, node, 20)) { switch (index_find_node(self, node)) {
case -3: case -3:
return -1; return -1;
case -2: case -2:
return 0; return 0;
default: default:
return 1; return 1;
} }
} }
static PyObject *index_m_has_node(indexObject *self, PyObject *args) static PyObject *index_m_has_node(indexObject *self, PyObject *args)
{ {
int ret = index_contains(self, args); int ret = index_contains(self, args);
if (ret < 0) if (ret < 0)
return NULL; return NULL;
return PyBool_FromLong((long)ret); return PyBool_FromLong((long)ret);
} }
static PyObject *index_m_rev(indexObject *self, PyObject *val) static PyObject *index_m_rev(indexObject *self, PyObject *val)
{ {
char *node; char *node;
int rev; int rev;
if (node_check(val, &node) == -1) if (node_check(self->nodelen, val, &node) == -1)
return NULL; return NULL;
rev = index_find_node(self, node, 20); rev = index_find_node(self, node);
if (rev >= -1) if (rev >= -1)
return PyInt_FromLong(rev); return PyInt_FromLong(rev);
if (rev == -2) if (rev == -2)
raise_revlog_error(); raise_revlog_error();
return NULL; return NULL;
} }
typedef uint64_t bitmask; typedef uint64_t bitmask;
PyObject *value) PyObject *value)
{ {
char *node; char *node;
long rev; long rev;
if (PySlice_Check(item) && value == NULL) if (PySlice_Check(item) && value == NULL)
return index_slice_del(self, item); return index_slice_del(self, item);
if (node_check(item, &node) == -1) if (node_check(self->nodelen, item, &node) == -1)
return -1; return -1;
if (value == NULL) if (value == NULL)
return self->ntinitialized ? nt_delete_node(&self->nt, node) return self->ntinitialized ? nt_delete_node(&self->nt, node)
: 0; : 0;
rev = PyInt_AsLong(value); rev = PyInt_AsLong(value);
if (rev > INT_MAX || rev < 0) { if (rev > INT_MAX || rev < 0) {
if (!PyErr_Occurred()) if (!PyErr_Occurred())
self->added_length = 0; self->added_length = 0;
self->data = NULL; self->data = NULL;
memset(&self->buf, 0, sizeof(self->buf)); memset(&self->buf, 0, sizeof(self->buf));
self->headrevs = NULL; self->headrevs = NULL;
self->filteredrevs = Py_None; self->filteredrevs = Py_None;
Py_INCREF(Py_None); Py_INCREF(Py_None);
self->ntinitialized = 0; self->ntinitialized = 0;
self->offsets = NULL; self->offsets = NULL;
self->nodelen = 20;
self->nullentry = NULL;
if (!PyArg_ParseTuple(args, "OO", &data_obj, &inlined_obj)) if (!PyArg_ParseTuple(args, "OO", &data_obj, &inlined_obj))
return -1; return -1;
if (!PyObject_CheckBuffer(data_obj)) { if (!PyObject_CheckBuffer(data_obj)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"data does not support buffer interface"); "data does not support buffer interface");
return -1; return -1;
} }
if (self->nodelen < 20 || self->nodelen > sizeof(nullid)) {
PyErr_SetString(PyExc_RuntimeError, "unsupported node size");
return -1;
}
self->nullentry = Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0, 0,
-1, -1, -1, -1, nullid, self->nodelen);
if (!self->nullentry)
return -1;
PyObject_GC_UnTrack(self->nullentry);
if (PyObject_GetBuffer(data_obj, &self->buf, PyBUF_SIMPLE) == -1) if (PyObject_GetBuffer(data_obj, &self->buf, PyBUF_SIMPLE) == -1)
return -1; return -1;
size = self->buf.len; size = self->buf.len;
self->inlined = inlined_obj && PyObject_IsTrue(inlined_obj); self->inlined = inlined_obj && PyObject_IsTrue(inlined_obj);
self->data = data_obj; self->data = data_obj;
_index_clearcaches(self); _index_clearcaches(self);
Py_XDECREF(self->filteredrevs); Py_XDECREF(self->filteredrevs);
if (self->buf.buf) { if (self->buf.buf) {
PyBuffer_Release(&self->buf); PyBuffer_Release(&self->buf);
memset(&self->buf, 0, sizeof(self->buf)); memset(&self->buf, 0, sizeof(self->buf));
} }
Py_XDECREF(self->data); Py_XDECREF(self->data);
PyMem_Free(self->added); PyMem_Free(self->added);
Py_XDECREF(self->nullentry);
PyObject_Del(self); PyObject_Del(self);
} }
static PySequenceMethods index_sequence_methods = { static PySequenceMethods index_sequence_methods = {
(lenfunc)index_length, /* sq_length */ (lenfunc)index_length, /* sq_length */
0, /* sq_concat */ 0, /* sq_concat */
0, /* sq_repeat */ 0, /* sq_repeat */
(ssizeargfunc)index_get, /* sq_item */ (ssizeargfunc)index_get, /* sq_item */
PyModule_AddObject(mod, "index", (PyObject *)&HgRevlogIndex_Type); PyModule_AddObject(mod, "index", (PyObject *)&HgRevlogIndex_Type);
nodetreeType.tp_new = PyType_GenericNew; nodetreeType.tp_new = PyType_GenericNew;
if (PyType_Ready(&nodetreeType) < 0) if (PyType_Ready(&nodetreeType) < 0)
return; return;
Py_INCREF(&nodetreeType); Py_INCREF(&nodetreeType);
PyModule_AddObject(mod, "nodetree", (PyObject *)&nodetreeType); PyModule_AddObject(mod, "nodetree", (PyObject *)&nodetreeType);
if (!nullentry) {
nullentry =
Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0, 0, -1,
-1, -1, -1, nullid, (Py_ssize_t)20);
}
if (nullentry)
PyObject_GC_UnTrack(nullentry);
caps = PyCapsule_New(&CAPI, "mercurial.cext.parsers.revlog_CAPI", NULL); caps = PyCapsule_New(&CAPI, "mercurial.cext.parsers.revlog_CAPI", NULL);
if (caps != NULL) if (caps != NULL)
PyModule_AddObject(mod, "revlog_CAPI", caps); PyModule_AddObject(mod, "revlog_CAPI", caps);
} }