This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5234

revlog: give formatting to clang-format
ClosedPublic

Authored by durin42 on Nov 6 2018, 11:44 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGe5ad3ef90aa1: revlog: give formatting to clang-format
Summary

This has two lines that are poorly formatted, both right after
PyObject_HEAD macros. It's possible that in the future there will be a
feature to tell clang-format that a token includes an end-of-line
character (in this case the ;), but for now I'm willing to live with
two poorly-formatted lines in a struct definition in exchange for not
thinking about how this file is formatted.

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

durin42 created this revision.Nov 6 2018, 11:44 AM
Closed by commit rHGe5ad3ef90aa1: revlog: give formatting to clang-format (authored by durin42). · Explain WhyNov 7 2018, 7:31 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 12464

contrib/clang-format-ignorelist

# Files that just need to be migrated to the formatter. # Files that just need to be migrated to the formatter.
# Do not add new files here! # Do not add new files here!
mercurial/cext/dirs.c mercurial/cext/dirs.c
mercurial/cext/manifest.c mercurial/cext/manifest.c
mercurial/cext/osutil.c mercurial/cext/osutil.c
mercurial/cext/revlog.c
# Vendored code that we should never format: # Vendored code that we should never format:
contrib/python-zstandard/c-ext/bufferutil.c contrib/python-zstandard/c-ext/bufferutil.c
contrib/python-zstandard/c-ext/compressionchunker.c contrib/python-zstandard/c-ext/compressionchunker.c
contrib/python-zstandard/c-ext/compressiondict.c contrib/python-zstandard/c-ext/compressiondict.c
contrib/python-zstandard/c-ext/compressionparams.c contrib/python-zstandard/c-ext/compressionparams.c
contrib/python-zstandard/c-ext/compressionreader.c contrib/python-zstandard/c-ext/compressionreader.c
contrib/python-zstandard/c-ext/compressionwriter.c contrib/python-zstandard/c-ext/compressionwriter.c
contrib/python-zstandard/c-ext/compressobj.c contrib/python-zstandard/c-ext/compressobj.c

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;
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 /* ; */
nodetree nt; nodetree nt;
} nodetreeObject; } nodetreeObject;
/* /*
* This class has two behaviors. * This class has two behaviors.
* *
* When used in a list-like way (with integer keys), we decode an * When used in a list-like way (with integer keys), we decode an
* entry in a RevlogNG index file on demand. Our last entry is a * entry in a RevlogNG index file on demand. Our last entry is a
* sentinel, always a nullid. We have limited support for * sentinel, always a nullid. We have limited support for
* integer-keyed insert and delete, only at elements right before the * integer-keyed insert and delete, only at elements right before the
* sentinel. * sentinel.
* *
* 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_buffer buf; /* buffer of data */ Py_buffer buf; /* buffer of data */
PyObject **cache; /* cached tuples */ PyObject **cache; /* cached tuples */
const char **offsets; /* populated on demand */ const char **offsets; /* populated on demand */
Py_ssize_t raw_length; /* original number of elements */ Py_ssize_t raw_length; /* original number of elements */
Py_ssize_t length; /* current number of elements */ Py_ssize_t length; /* current number of elements */
PyObject *added; /* populated on demand */ PyObject *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)
{ {
if (self->added == NULL) if (self->added == NULL)
return self->length; return self->length;
return self->length + PyList_GET_SIZE(self->added); return self->length + PyList_GET_SIZE(self->added);
if (dict == NULL) { if (dict == NULL) {
goto cleanup; goto cleanup;
} }
Py_INCREF(dict); Py_INCREF(dict);
errclass = PyDict_GetItemString(dict, "RevlogError"); errclass = PyDict_GetItemString(dict, "RevlogError");
if (errclass == NULL) { if (errclass == NULL) {
PyErr_SetString(PyExc_SystemError, PyErr_SetString(PyExc_SystemError,
"could not find RevlogError"); "could not find RevlogError");
goto cleanup; goto cleanup;
} }
/* value of exception is ignored by callers */ /* value of exception is ignored by callers */
PyErr_SetString(errclass, "RevlogError"); PyErr_SetString(errclass, "RevlogError");
cleanup: cleanup:
Py_XDECREF(dict); Py_XDECREF(dict);
Py_XDECREF(mod); Py_XDECREF(mod);
} }
/* /*
* Return a pointer to the beginning of a RevlogNG record. * Return a pointer to the beginning of a RevlogNG record.
*/ */
static const char *index_deref(indexObject *self, Py_ssize_t pos) static const char *index_deref(indexObject *self, Py_ssize_t pos)
{ {
if (self->inlined && pos > 0) { if (self->inlined && pos > 0) {
if (self->offsets == NULL) { if (self->offsets == NULL) {
self->offsets = PyMem_Malloc(self->raw_length * self->offsets = PyMem_Malloc(self->raw_length *
sizeof(*self->offsets)); sizeof(*self->offsets));
if (self->offsets == NULL) if (self->offsets == NULL)
return (const char *)PyErr_NoMemory(); return (const char *)PyErr_NoMemory();
inline_scan(self, self->offsets); inline_scan(self, self->offsets);
} }
return self->offsets[pos]; return self->offsets[pos];
} }
return (const char *)(self->buf.buf) + pos * v1_hdrsize; return (const char *)(self->buf.buf) + pos * v1_hdrsize;
} }
static inline int index_get_parents(indexObject *self, Py_ssize_t rev, static inline int index_get_parents(indexObject *self, Py_ssize_t rev, int *ps,
int *ps, int maxrev) int maxrev)
{ {
if (rev >= self->length) { if (rev >= self->length) {
PyObject *tuple = PyList_GET_ITEM(self->added, rev - self->length); PyObject *tuple =
PyList_GET_ITEM(self->added, rev - self->length);
ps[0] = (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 5)); ps[0] = (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 5));
ps[1] = (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 6)); ps[1] = (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 6));
} else { } else {
const char *data = index_deref(self, rev); const char *data = index_deref(self, rev);
ps[0] = getbe32(data + 24); ps[0] = getbe32(data + 24);
ps[1] = getbe32(data + 28); ps[1] = getbe32(data + 28);
} }
/* If index file is corrupted, ps[] may point to invalid revisions. So /* If index file is corrupted, ps[] may point to invalid revisions. So
* there is a risk of buffer overflow to trust them unconditionally. */ * there is a risk of buffer overflow to trust them unconditionally. */
if (ps[0] > maxrev || ps[1] > maxrev) { if (ps[0] > maxrev || ps[1] > maxrev) {
PyErr_SetString(PyExc_ValueError, "parent out of range"); PyErr_SetString(PyExc_ValueError, "parent out of range");
return -1; return -1;
} }
return 0; return 0;
} }
/* /*
* RevlogNG format (all in big endian, data may be inlined): * RevlogNG format (all in big endian, data may be inlined):
* 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
comp_len = getbe32(data + 8); comp_len = getbe32(data + 8);
uncomp_len = getbe32(data + 12); uncomp_len = getbe32(data + 12);
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;
entry = Py_BuildValue(tuple_format, offset_flags, comp_len, entry = Py_BuildValue(tuple_format, offset_flags, comp_len, uncomp_len,
uncomp_len, base_rev, link_rev, base_rev, link_rev, parent_1, parent_2, c_node_id,
parent_1, parent_2, c_node_id, 20); 20);
if (entry) { if (entry) {
PyObject_GC_UnTrack(entry); PyObject_GC_UnTrack(entry);
Py_INCREF(entry); Py_INCREF(entry);
} }
self->cache[pos] = entry; self->cache[pos] = entry;
{ {
PyObject *obj = PyDict_New(); PyObject *obj = PyDict_New();
PyObject *s = NULL; PyObject *s = NULL;
PyObject *t = NULL; PyObject *t = NULL;
if (obj == NULL) if (obj == NULL)
return NULL; return NULL;
#define istat(__n, __d) \ #define istat(__n, __d) \
do { \ do { \
s = PyBytes_FromString(__d); \ s = PyBytes_FromString(__d); \
t = PyInt_FromSsize_t(self->__n); \ t = PyInt_FromSsize_t(self->__n); \
if (!s || !t) \ if (!s || !t) \
goto bail; \ goto bail; \
if (PyDict_SetItem(obj, s, t) == -1) \ if (PyDict_SetItem(obj, s, t) == -1) \
goto bail; \ goto bail; \
Py_CLEAR(s); \ Py_CLEAR(s); \
Py_CLEAR(t); \ Py_CLEAR(t); \
} while (0) } while (0)
if (self->added) { if (self->added) {
Py_ssize_t len = PyList_GET_SIZE(self->added); Py_ssize_t len = PyList_GET_SIZE(self->added);
s = PyBytes_FromString("index entries added"); s = PyBytes_FromString("index entries added");
t = PyInt_FromSsize_t(len); t = PyInt_FromSsize_t(len);
if (!s || !t) if (!s || !t)
goto bail; goto bail;
long revnum; long revnum;
Py_ssize_t k; Py_ssize_t k;
Py_ssize_t i; Py_ssize_t i;
Py_ssize_t l; Py_ssize_t l;
int r; int r;
int parents[2]; int parents[2];
/* Internal data structure: /* Internal data structure:
* tovisit: array of length len+1 (all revs + nullrev), filled upto lentovisit * tovisit: array of length len+1 (all revs + nullrev), filled upto
* lentovisit
* *
* revstates: array of length len+1 (all revs + nullrev) */ * revstates: array of length len+1 (all revs + nullrev) */
int *tovisit = NULL; int *tovisit = NULL;
long lentovisit = 0; long lentovisit = 0;
enum { RS_SEEN = 1, RS_ROOT = 2, RS_REACHABLE = 4 }; enum { RS_SEEN = 1, RS_ROOT = 2, RS_REACHABLE = 4 };
char *revstates = NULL; char *revstates = NULL;
/* Get arguments */ /* Get arguments */
if (!PyArg_ParseTuple(args, "lO!O!O!", &minroot, &PyList_Type, &heads, if (!PyArg_ParseTuple(args, "lO!O!O!", &minroot, &PyList_Type, &heads,
&PyList_Type, &roots, &PyList_Type, &roots, &PyBool_Type,
&PyBool_Type, &includepatharg)) &includepatharg))
goto bail; goto bail;
if (includepatharg == Py_True) if (includepatharg == Py_True)
includepath = 1; includepath = 1;
/* Initialize return set */ /* Initialize return set */
reachable = PyList_New(0); reachable = PyList_New(0);
if (reachable == NULL) if (reachable == NULL)
/* Add its parents to the list of nodes to visit */ /* Add its parents to the list of nodes to visit */
if (revnum == -1) if (revnum == -1)
continue; continue;
r = index_get_parents(self, revnum, parents, (int)len - 1); r = index_get_parents(self, revnum, parents, (int)len - 1);
if (r < 0) if (r < 0)
goto bail; goto bail;
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
if (!(revstates[parents[i] + 1] & RS_SEEN) if (!(revstates[parents[i] + 1] & RS_SEEN) &&
&& parents[i] >= minroot) { parents[i] >= minroot) {
tovisit[lentovisit++] = parents[i]; tovisit[lentovisit++] = parents[i];
revstates[parents[i] + 1] |= RS_SEEN; revstates[parents[i] + 1] |= RS_SEEN;
} }
} }
} }
/* Find all the nodes in between the roots we found and the heads /* Find all the nodes in between the roots we found and the heads
* and add them to the reachable set */ * and add them to the reachable set */
if (includepath == 1) { if (includepath == 1) {
long minidx = minroot; long minidx = minroot;
if (minidx < 0) if (minidx < 0)
minidx = 0; minidx = 0;
for (i = minidx; i < len; i++) { for (i = minidx; i < len; i++) {
if (!(revstates[i + 1] & RS_SEEN)) if (!(revstates[i + 1] & RS_SEEN))
continue; continue;
r = index_get_parents(self, i, parents, (int)len - 1); r = index_get_parents(self, i, parents, (int)len - 1);
/* Corrupted index file, error is set from /* Corrupted index file, error is set from
* index_get_parents */ * index_get_parents */
if (r < 0) if (r < 0)
goto bail; goto bail;
if (((revstates[parents[0] + 1] | if (((revstates[parents[0] + 1] |
revstates[parents[1] + 1]) & RS_REACHABLE) revstates[parents[1] + 1]) &
&& !(revstates[i + 1] & RS_REACHABLE)) { RS_REACHABLE) &&
!(revstates[i + 1] & RS_REACHABLE)) {
revstates[i + 1] |= RS_REACHABLE; revstates[i + 1] |= RS_REACHABLE;
val = PyInt_FromSsize_t(i); val = PyInt_FromSsize_t(i);
if (val == NULL) if (val == NULL)
goto bail; goto bail;
r = PyList_Append(reachable, val); r = PyList_Append(reachable, val);
Py_DECREF(val); Py_DECREF(val);
if (r < 0) if (r < 0)
goto bail; goto bail;
if (!PyArg_ParseTuple(args, "O", &roots)) if (!PyArg_ParseTuple(args, "O", &roots))
goto done; goto done;
if (roots == NULL || !PyList_Check(roots)) { if (roots == NULL || !PyList_Check(roots)) {
PyErr_SetString(PyExc_TypeError, "roots must be a list"); PyErr_SetString(PyExc_TypeError, "roots must be a list");
goto done; goto done;
} }
phases = calloc(len, 1); /* phase per rev: {0: public, 1: draft, 2: secret} */ phases = calloc(
len, 1); /* phase per rev: {0: public, 1: draft, 2: secret} */
if (phases == NULL) { if (phases == NULL) {
PyErr_NoMemory(); PyErr_NoMemory();
goto done; goto done;
} }
/* Put the phase information of all the roots in phases */ /* Put the phase information of all the roots in phases */
numphase = PyList_GET_SIZE(roots)+1; numphase = PyList_GET_SIZE(roots) + 1;
minrevallphases = len + 1; minrevallphases = len + 1;
phasessetlist = PyList_New(numphase); phasessetlist = PyList_New(numphase);
if (phasessetlist == NULL) if (phasessetlist == NULL)
goto done; goto done;
PyList_SET_ITEM(phasessetlist, 0, Py_None); PyList_SET_ITEM(phasessetlist, 0, Py_None);
Py_INCREF(Py_None); Py_INCREF(Py_None);
for (i = 0; i < numphase-1; i++) { for (i = 0; i < numphase - 1; i++) {
phaseroots = PyList_GET_ITEM(roots, i); phaseroots = PyList_GET_ITEM(roots, i);
phaseset = PySet_New(NULL); phaseset = PySet_New(NULL);
if (phaseset == NULL) if (phaseset == NULL)
goto release; goto release;
PyList_SET_ITEM(phasessetlist, i+1, phaseset); PyList_SET_ITEM(phasessetlist, i + 1, phaseset);
if (!PyList_Check(phaseroots)) { if (!PyList_Check(phaseroots)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"roots item must be a list"); "roots item must be a list");
goto release; goto release;
} }
minrevphase = add_roots_get_min(self, phaseroots, i+1, phases); minrevphase =
add_roots_get_min(self, phaseroots, i + 1, phases);
if (minrevphase == -2) /* Error from add_roots_get_min */ if (minrevphase == -2) /* Error from add_roots_get_min */
goto release; goto release;
minrevallphases = MIN(minrevallphases, minrevphase); minrevallphases = MIN(minrevallphases, minrevphase);
} }
/* Propagate the phase information from the roots to the revs */ /* Propagate the phase information from the roots to the revs */
if (minrevallphases != -1) { if (minrevallphases != -1) {
int parents[2]; int parents[2];
for (i = minrevallphases; i < len; i++) { for (i = minrevallphases; i < len; i++) {
if (index_get_parents(self, i, parents, if (index_get_parents(self, i, parents, (int)len - 1) <
(int)len - 1) < 0) 0)
goto release; goto release;
set_phase_from_parents(phases, parents[0], parents[1], i); set_phase_from_parents(phases, parents[0], parents[1],
i);
} }
} }
/* Transform phase list to a python list */ /* Transform phase list to a python list */
phasessize = PyInt_FromSsize_t(len); phasessize = PyInt_FromSsize_t(len);
if (phasessize == NULL) if (phasessize == NULL)
goto release; goto release;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
phase = phases[i]; phase = phases[i];
/* We only store the sets of phase for non public phase, the public phase /* We only store the sets of phase for non public phase, the
* is computed as a difference */ * public phase is computed as a difference */
if (phase != 0) { if (phase != 0) {
phaseset = PyList_GET_ITEM(phasessetlist, phase); phaseset = PyList_GET_ITEM(phasessetlist, phase);
rev = PyInt_FromSsize_t(i); rev = PyInt_FromSsize_t(i);
if (rev == NULL) if (rev == NULL)
goto release; goto release;
PySet_Add(phaseset, rev); PySet_Add(phaseset, rev);
Py_XDECREF(rev); Py_XDECREF(rev);
} }
Py_DECREF(self->filteredrevs); Py_DECREF(self->filteredrevs);
self->filteredrevs = filteredrevs; self->filteredrevs = filteredrevs;
Py_INCREF(filteredrevs); Py_INCREF(filteredrevs);
if (filteredrevs != Py_None) { if (filteredrevs != Py_None) {
filter = PyObject_GetAttrString(filteredrevs, "__contains__"); filter = PyObject_GetAttrString(filteredrevs, "__contains__");
if (!filter) { if (!filter) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(
PyExc_TypeError,
"filteredrevs has no attribute __contains__"); "filteredrevs has no attribute __contains__");
goto bail; goto bail;
} }
} }
len = index_length(self); len = index_length(self);
heads = PyList_New(0); heads = PyList_New(0);
if (heads == NULL) if (heads == NULL)
goto bail; goto bail;
PyErr_NoMemory(); PyErr_NoMemory();
goto bail; goto bail;
} }
for (i = len - 1; i >= 0; i--) { for (i = len - 1; i >= 0; i--) {
int isfiltered; int isfiltered;
int parents[2]; int parents[2];
/* If nothead[i] == 1, it means we've seen an unfiltered child of this /* If nothead[i] == 1, it means we've seen an unfiltered child
* node already, and therefore this node is not filtered. So we can skip * of this node already, and therefore this node is not
* the expensive check_filter step. * filtered. So we can skip the expensive check_filter step.
*/ */
if (nothead[i] != 1) { if (nothead[i] != 1) {
isfiltered = check_filter(filter, i); isfiltered = check_filter(filter, i);
if (isfiltered == -1) { if (isfiltered == -1) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"unable to check filter"); "unable to check filter");
goto bail; goto bail;
} }
if (isfiltered) { if (isfiltered) {
nothead[i] = 1; nothead[i] = 1;
continue; continue;
} }
} }
* *
* Callers must ensure that rev >= 0 or illegal memory access may occur. * Callers must ensure that rev >= 0 or illegal memory access may occur.
*/ */
static inline int index_baserev(indexObject *self, int rev) static inline int index_baserev(indexObject *self, int rev)
{ {
const char *data; const char *data;
if (rev >= self->length) { if (rev >= self->length) {
PyObject *tuple = PyList_GET_ITEM(self->added, rev - self->length); PyObject *tuple =
PyList_GET_ITEM(self->added, rev - self->length);
return (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 3)); return (int)PyInt_AS_LONG(PyTuple_GET_ITEM(tuple, 3));
} } else {
else {
data = index_deref(self, rev); data = index_deref(self, rev);
if (data == NULL) { if (data == NULL) {
return -2; return -2;
} }
return getbe32(data + 16); return getbe32(data + 16);
} }
} }
return NULL; return NULL;
} }
if (PyInt_Check(stoparg)) { if (PyInt_Check(stoparg)) {
stoprev = (int)PyInt_AsLong(stoparg); stoprev = (int)PyInt_AsLong(stoparg);
if (stoprev == -1 && PyErr_Occurred()) { if (stoprev == -1 && PyErr_Occurred()) {
return NULL; return NULL;
} }
} } else if (stoparg == Py_None) {
else if (stoparg == Py_None) {
stoprev = -2; stoprev = -2;
} } else {
else {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"stoprev must be integer or None"); "stoprev must be integer or None");
return NULL; return NULL;
} }
if (rev < 0 || rev >= length) { if (rev < 0 || rev >= length) {
PyErr_SetString(PyExc_ValueError, "revlog index out of range"); PyErr_SetString(PyExc_ValueError, "revlog index out of range");
return NULL; return NULL;
} }
if (PyList_Append(chain, value)) { if (PyList_Append(chain, value)) {
Py_DECREF(value); Py_DECREF(value);
goto bail; goto bail;
} }
Py_DECREF(value); Py_DECREF(value);
if (generaldelta) { if (generaldelta) {
iterrev = baserev; iterrev = baserev;
} } else {
else {
iterrev--; iterrev--;
} }
if (iterrev < 0) { if (iterrev < 0) {
break; break;
} }
if (iterrev >= length) { if (iterrev >= length) {
PyErr_SetString(PyExc_IndexError, "revision outside index"); PyErr_SetString(PyExc_IndexError,
"revision outside index");
return NULL; return NULL;
} }
baserev = index_baserev(self, iterrev); baserev = index_baserev(self, iterrev);
/* This should never happen. */ /* This should never happen. */
if (baserev <= -2) { if (baserev <= -2) {
/* Error should be set by index_deref() */ /* Error should be set by index_deref() */
assert(PyErr_Occurred()); assert(PyErr_Occurred());
goto bail; goto bail;
} }
} }
if (iterrev == stoprev) { if (iterrev == stoprev) {
stopped = 1; stopped = 1;
} } else {
else {
PyObject *value = PyInt_FromLong(iterrev); PyObject *value = PyInt_FromLong(iterrev);
if (value == NULL) { if (value == NULL) {
goto bail; goto bail;
} }
if (PyList_Append(chain, value)) { if (PyList_Append(chain, value)) {
Py_DECREF(value); Py_DECREF(value);
goto bail; goto bail;
} }
bail: bail:
Py_DECREF(chain); Py_DECREF(chain);
return NULL; return NULL;
} }
static inline int nt_level(const char *node, Py_ssize_t level) static inline int nt_level(const char *node, Py_ssize_t level)
{ {
int v = node[level>>1]; int v = node[level >> 1];
if (!(level & 1)) if (!(level & 1))
v >>= 4; v >>= 4;
return v & 0xf; return v & 0xf;
} }
/* /*
* Return values: * Return values:
* *
* -4: match is ambiguous (multiple candidates) * -4: match is ambiguous (multiple candidates)
* -2: not found * -2: not found
* 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 (nodelen == 20 && node[0] == '\0' && memcmp(node, nullid, 20) == 0)
return -1; return -1;
if (hex) if (hex)
static int nt_new(nodetree *self) static int nt_new(nodetree *self)
{ {
if (self->length == self->capacity) { if (self->length == self->capacity) {
unsigned newcapacity; unsigned newcapacity;
nodetreenode *newnodes; nodetreenode *newnodes;
newcapacity = self->capacity * 2; newcapacity = self->capacity * 2;
if (newcapacity >= INT_MAX / sizeof(nodetreenode)) { if (newcapacity >= INT_MAX / sizeof(nodetreenode)) {
PyErr_SetString(PyExc_MemoryError, "overflow in nt_new"); PyErr_SetString(PyExc_MemoryError,
"overflow in nt_new");
return -1; return -1;
} }
newnodes = realloc(self->nodes, newcapacity * sizeof(nodetreenode)); newnodes =
realloc(self->nodes, newcapacity * sizeof(nodetreenode));
if (newnodes == NULL) { if (newnodes == NULL) {
PyErr_SetString(PyExc_MemoryError, "out of memory"); PyErr_SetString(PyExc_MemoryError, "out of memory");
return -1; return -1;
} }
self->capacity = newcapacity; self->capacity = newcapacity;
self->nodes = newnodes; self->nodes = newnodes;
memset(&self->nodes[self->length], 0, memset(&self->nodes[self->length], 0,
sizeof(nodetreenode) * (self->capacity - self->length)); sizeof(nodetreenode) * (self->capacity - self->length));
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 = index_node_existing(self->index, -(v + 2)); const char *oldnode =
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, 20)) {
n->children[k] = -rev - 2; n->children[k] = -rev - 2;
return 0; return 0;
} }
node = index_node_existing(self->nt.index, rev); node = index_node_existing(self->nt.index, rev);
if (nt_insert(&self->nt, node, (int)rev) == -1) if (nt_insert(&self->nt, node, (int)rev) == -1)
return NULL; return NULL;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static int nt_delete_node(nodetree *self, const char *node) static int nt_delete_node(nodetree *self, const char *node)
{ {
/* rev==-2 happens to get encoded as 0, which is interpreted as not set */ /* rev==-2 happens to get encoded as 0, which is interpreted as not set
*/
return nt_insert(self, node, -2); return nt_insert(self, node, -2);
} }
static int nt_init(nodetree *self, indexObject *index, unsigned capacity) static int nt_init(nodetree *self, indexObject *index, unsigned capacity)
{ {
/* Initialize before overflow-checking to avoid nt_dealloc() crash. */ /* Initialize before overflow-checking to avoid nt_dealloc() crash. */
self->nodes = NULL; self->nodes = NULL;
static int ntobj_init(nodetreeObject *self, PyObject *args) static int ntobj_init(nodetreeObject *self, PyObject *args)
{ {
PyObject *index; PyObject *index;
unsigned capacity; unsigned capacity;
if (!PyArg_ParseTuple(args, "O!I", &indexType, &index, &capacity)) if (!PyArg_ParseTuple(args, "O!I", &indexType, &index, &capacity))
return -1; return -1;
Py_INCREF(index); Py_INCREF(index);
return nt_init(&self->nt, (indexObject*)index, capacity); return nt_init(&self->nt, (indexObject *)index, capacity);
} }
static int nt_partialmatch(nodetree *self, const char *node, static int nt_partialmatch(nodetree *self, const char *node, Py_ssize_t nodelen)
Py_ssize_t nodelen)
{ {
return nt_find(self, node, nodelen, 1); return nt_find(self, node, nodelen, 1);
} }
/* /*
* Find the length of the shortest unique prefix of node. * Find the length of the shortest unique prefix of node.
* *
* Return values: * Return values:
static void ntobj_dealloc(nodetreeObject *self) static void ntobj_dealloc(nodetreeObject *self)
{ {
Py_XDECREF(self->nt.index); Py_XDECREF(self->nt.index);
nt_dealloc(&self->nt); nt_dealloc(&self->nt);
PyObject_Del(self); PyObject_Del(self);
} }
static PyMethodDef ntobj_methods[] = { static PyMethodDef ntobj_methods[] = {
{"insert", (PyCFunction)ntobj_insert, METH_VARARGS, {"insert", (PyCFunction)ntobj_insert, METH_VARARGS,
"insert an index entry"}, "insert an index entry"},
{"shortest", (PyCFunction)ntobj_shortest, METH_VARARGS, {"shortest", (PyCFunction)ntobj_shortest, METH_VARARGS,
"find length of shortest hex nodeid of a binary ID"}, "find length of shortest hex nodeid of a binary ID"},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyTypeObject nodetreeType = { static PyTypeObject nodetreeType = {
PyVarObject_HEAD_INIT(NULL, 0) /* header */ PyVarObject_HEAD_INIT(NULL, 0) /* header */
"parsers.nodetree", /* tp_name */ "parsers.nodetree", /* tp_name */
sizeof(nodetreeObject) , /* tp_basicsize */ sizeof(nodetreeObject), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
(destructor)ntobj_dealloc, /* tp_dealloc */ (destructor)ntobj_dealloc, /* tp_dealloc */
0, /* tp_print */ 0, /* tp_print */
0, /* tp_getattr */ 0, /* tp_getattr */
0, /* tp_setattr */ 0, /* tp_setattr */
0, /* tp_compare */ 0, /* tp_compare */
0, /* tp_repr */ 0, /* tp_repr */
0, /* tp_as_number */ 0, /* tp_as_number */
0, /* tp_as_sequence */ 0, /* tp_as_sequence */
0, /* tp_as_mapping */ 0, /* tp_as_mapping */
0, /* tp_hash */ 0, /* tp_hash */
0, /* tp_call */ 0, /* tp_call */
0, /* tp_str */ 0, /* tp_str */
0, /* tp_getattro */ 0, /* tp_getattro */
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */ Py_TPFLAGS_DEFAULT, /* tp_flags */
"nodetree", /* tp_doc */ "nodetree", /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
0, /* tp_weaklistoffset */ 0, /* tp_weaklistoffset */
0, /* tp_iter */ 0, /* tp_iter */
0, /* tp_iternext */ 0, /* tp_iternext */
ntobj_methods, /* tp_methods */ ntobj_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ 0, /* tp_getset */
0, /* tp_base */ 0, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)ntobj_init, /* tp_init */ (initproc)ntobj_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
}; };
static int index_init_nt(indexObject *self) static int index_init_nt(indexObject *self)
{ {
if (!self->ntinitialized) { if (!self->ntinitialized) {
if (nt_init(&self->nt, self, (int)self->raw_length) == -1) { if (nt_init(&self->nt, self, (int)self->raw_length) == -1) {
nt_dealloc(&self->nt); nt_dealloc(&self->nt);
return -1; return -1;
/* /*
* 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, static int index_find_node(indexObject *self, const char *node,
const char *node, Py_ssize_t nodelen) 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, nodelen, 0);
if (rev == -2) if (rev == -2)
raise_revlog_error(); raise_revlog_error();
return NULL; return NULL;
} }
/* /*
* Fully populate the radix tree. * Fully populate the radix tree.
*/ */
static int index_populate_nt(indexObject *self) { static int index_populate_nt(indexObject *self)
{
int rev; int rev;
if (self->ntrev > 0) { if (self->ntrev > 0) {
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 -1; return -1;
if (nt_insert(&self->nt, n, rev) == -1) if (nt_insert(&self->nt, n, rev) == -1)
return -1; return -1;
typedef uint64_t bitmask; typedef uint64_t bitmask;
/* /*
* Given a disjoint set of revs, return all candidates for the * Given a disjoint set of revs, return all candidates for the
* greatest common ancestor. In revset notation, this is the set * greatest common ancestor. In revset notation, this is the set
* "heads(::a and ::b and ...)" * "heads(::a and ::b and ...)"
*/ */
static PyObject *find_gca_candidates(indexObject *self, const int *revs, static PyObject *find_gca_candidates(indexObject *self, const int *revs,
int revcount) int revcount)
{ {
const bitmask allseen = (1ull << revcount) - 1; const bitmask allseen = (1ull << revcount) - 1;
const bitmask poison = 1ull << revcount; const bitmask poison = 1ull << revcount;
PyObject *gca = PyList_New(0); PyObject *gca = PyList_New(0);
int i, v, interesting; int i, v, interesting;
int maxrev = -1; int maxrev = -1;
bitmask sp; bitmask sp;
bitmask *seen; bitmask *seen;
int p = parents[i]; int p = parents[i];
if (p == -1) if (p == -1)
continue; continue;
sp = seen[p]; sp = seen[p];
if (sv < poison) { if (sv < poison) {
if (sp == 0) { if (sp == 0) {
seen[p] = sv; seen[p] = sv;
interesting++; interesting++;
} } else if (sp != sv)
else if (sp != sv)
seen[p] |= sv; seen[p] |= sv;
} else { } else {
if (sp && sp < poison) if (sp && sp < poison)
interesting--; interesting--;
seen[p] = sv; seen[p] = sv;
} }
} }
} }
int i, j, v, ninteresting; int i, j, v, ninteresting;
PyObject *dict = NULL, *keys = NULL; PyObject *dict = NULL, *keys = NULL;
long *seen = NULL; long *seen = NULL;
int maxrev = -1; int maxrev = -1;
long final; long final;
if (revcount > capacity) { if (revcount > capacity) {
PyErr_Format(PyExc_OverflowError, PyErr_Format(PyExc_OverflowError,
"bitset size (%ld) > capacity (%ld)", "bitset size (%ld) > capacity (%ld)",
(long)revcount, (long)capacity); (long)revcount, (long)capacity);
return NULL; return NULL;
} }
for (i = 0; i < revcount; i++) { for (i = 0; i < revcount; i++) {
int n = (int)PyInt_AsLong(PyList_GET_ITEM(revs, i)); int n = (int)PyInt_AsLong(PyList_GET_ITEM(revs, i));
if (n > maxrev) if (n > maxrev)
maxrev = n; maxrev = n;
} }
interesting[sv] += 1; interesting[sv] += 1;
seen[p] = sv; seen[p] = sv;
if (sp) { if (sp) {
interesting[sp] -= 1; interesting[sp] -= 1;
if (interesting[sp] == 0) if (interesting[sp] == 0)
ninteresting -= 1; ninteresting -= 1;
} }
} }
} } else if (dv == dp - 1) {
else if (dv == dp - 1) {
long nsp = sp | sv; long nsp = sp | sv;
if (nsp == sp) if (nsp == sp)
continue; continue;
seen[p] = nsp; seen[p] = nsp;
interesting[sp] -= 1; interesting[sp] -= 1;
if (interesting[sp] == 0) if (interesting[sp] == 0)
ninteresting -= 1; ninteresting -= 1;
if (interesting[nsp] == 0) if (interesting[nsp] == 0)
for (i = 0; i < argcount; i++) { for (i = 0; i < argcount; i++) {
static const int capacity = 24; static const int capacity = 24;
PyObject *obj = PySequence_GetItem(args, i); PyObject *obj = PySequence_GetItem(args, i);
bitmask x; bitmask x;
long val; long val;
if (!PyInt_Check(obj)) { if (!PyInt_Check(obj)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"arguments must all be ints"); "arguments must all be ints");
Py_DECREF(obj); Py_DECREF(obj);
goto bail; goto bail;
} }
val = PyInt_AsLong(obj); val = PyInt_AsLong(obj);
Py_DECREF(obj); Py_DECREF(obj);
if (val == -1) { if (val == -1) {
ret = PyList_New(0); ret = PyList_New(0);
goto done; goto done;
} }
if (val < 0 || val >= len) { if (val < 0 || val >= len) {
PyErr_SetString(PyExc_IndexError, PyErr_SetString(PyExc_IndexError, "index out of range");
"index out of range");
goto bail; goto bail;
} }
/* this cheesy bloom filter lets us avoid some more /* this cheesy bloom filter lets us avoid some more
* expensive duplicate checks in the common set-is-disjoint * expensive duplicate checks in the common set-is-disjoint
* case */ * case */
x = 1ull << (val & 0x3f); x = 1ull << (val & 0x3f);
if (repeat & x) { if (repeat & x) {
int k; int k;
for (k = 0; k < revcount; k++) { for (k = 0; k < revcount; k++) {
if (val == revs[k]) if (val == revs[k])
goto duplicate; goto duplicate;
} }
} } else
else repeat |= x; repeat |= x;
if (revcount >= capacity) { if (revcount >= capacity) {
PyErr_Format(PyExc_OverflowError, PyErr_Format(PyExc_OverflowError,
"bitset size (%d) > capacity (%d)", "bitset size (%d) > capacity (%d)",
revcount, capacity); revcount, capacity);
goto bail; goto bail;
} }
revs[revcount++] = (int)val; revs[revcount++] = (int)val;
duplicate:; duplicate:;
} }
if (revcount == 0) { if (revcount == 0) {
ret = PyList_New(0); ret = PyList_New(0);
static int index_slice_del(indexObject *self, PyObject *item) static int index_slice_del(indexObject *self, PyObject *item)
{ {
Py_ssize_t start, stop, step, slicelength; Py_ssize_t start, stop, step, slicelength;
Py_ssize_t length = index_length(self) + 1; Py_ssize_t length = index_length(self) + 1;
int ret = 0; int ret = 0;
/* Argument changed from PySliceObject* to PyObject* in Python 3. */ /* Argument changed from PySliceObject* to PyObject* in Python 3. */
#ifdef IS_PY3K #ifdef IS_PY3K
if (PySlice_GetIndicesEx(item, length, if (PySlice_GetIndicesEx(item, length, &start, &stop, &step,
&start, &stop, &step, &slicelength) < 0) &slicelength) < 0)
#else #else
if (PySlice_GetIndicesEx((PySliceObject*)item, length, if (PySlice_GetIndicesEx((PySliceObject *)item, length, &start, &stop,
&start, &stop, &step, &slicelength) < 0) &step, &slicelength) < 0)
#endif #endif
return -1; return -1;
if (slicelength <= 0) if (slicelength <= 0)
return 0; return 0;
if ((step < 0 && start < stop) || (step > 0 && start > stop)) if ((step < 0 && start < stop) || (step > 0 && start > stop))
stop = start; stop = start;
if (step < 0) { if (step < 0) {
stop = start + 1; stop = start + 1;
start = stop + step*(slicelength - 1) - 1; start = stop + step * (slicelength - 1) - 1;
step = -step; step = -step;
} }
if (step != 1) { if (step != 1) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"revlog index delete requires step size of 1"); "revlog index delete requires step size of 1");
return -1; return -1;
} }
if (stop != length - 1) { if (stop != length - 1) {
PyErr_SetString(PyExc_IndexError, PyErr_SetString(PyExc_IndexError,
"revlog index deletion indices are invalid"); "revlog index deletion indices are invalid");
return -1; return -1;
} }
if (start < self->length) { if (start < self->length) {
if (self->ntinitialized) { if (self->ntinitialized) {
Py_ssize_t i; Py_ssize_t i;
for (i = start + 1; i < self->length; i++) { for (i = start + 1; i < self->length; i++) {
if (self->ntinitialized) { if (self->ntinitialized) {
index_invalidate_added(self, start - self->length); index_invalidate_added(self, start - self->length);
if (self->ntrev > start) if (self->ntrev > start)
self->ntrev = (int)start; self->ntrev = (int)start;
} }
if (self->added) if (self->added)
ret = PyList_SetSlice(self->added, start - self->length, ret = PyList_SetSlice(self->added, start - self->length,
PyList_GET_SIZE(self->added), NULL); PyList_GET_SIZE(self->added), NULL);
done: done:
Py_CLEAR(self->headrevs); Py_CLEAR(self->headrevs);
return ret; return ret;
} }
/* /*
* Supported ops: * Supported ops:
* *
* slice deletion * slice deletion
* string assignment (extend node->rev mapping) * string assignment (extend node->rev mapping)
* string deletion (shrink node->rev mapping) * string deletion (shrink node->rev mapping)
*/ */
static int index_assign_subscript(indexObject *self, PyObject *item, static int index_assign_subscript(indexObject *self, PyObject *item,
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(item, &node) == -1)
return -1; return -1;
if (value == NULL) if (value == NULL)
return self->ntinitialized ? nt_delete_node(&self->nt, node) : 0; return self->ntinitialized ? nt_delete_node(&self->nt, node)
: 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())
PyErr_SetString(PyExc_ValueError, "rev out of range"); PyErr_SetString(PyExc_ValueError, "rev out of range");
return -1; return -1;
} }
if (index_init_nt(self) == -1) if (index_init_nt(self) == -1)
return len; return len;
} }
static int index_init(indexObject *self, PyObject *args) static int index_init(indexObject *self, PyObject *args)
{ {
PyObject *data_obj, *inlined_obj; PyObject *data_obj, *inlined_obj;
Py_ssize_t size; Py_ssize_t size;
/* Initialize before argument-checking to avoid index_dealloc() crash. */ /* Initialize before argument-checking to avoid index_dealloc() crash.
*/
self->raw_length = 0; self->raw_length = 0;
self->added = NULL; self->added = NULL;
self->cache = NULL; self->cache = NULL;
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;
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 (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);
memset(&self->buf, 0, sizeof(self->buf)); memset(&self->buf, 0, sizeof(self->buf));
} }
Py_XDECREF(self->data); Py_XDECREF(self->data);
Py_XDECREF(self->added); Py_XDECREF(self->added);
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 */
0, /* sq_slice */ 0, /* sq_slice */
0, /* sq_ass_item */ 0, /* sq_ass_item */
0, /* sq_ass_slice */ 0, /* sq_ass_slice */
(objobjproc)index_contains, /* sq_contains */ (objobjproc)index_contains, /* sq_contains */
}; };
static PyMappingMethods index_mapping_methods = { static PyMappingMethods index_mapping_methods = {
(lenfunc)index_length, /* mp_length */ (lenfunc)index_length, /* mp_length */
(binaryfunc)index_getitem, /* mp_subscript */ (binaryfunc)index_getitem, /* mp_subscript */
(objobjargproc)index_assign_subscript, /* mp_ass_subscript */ (objobjargproc)index_assign_subscript, /* mp_ass_subscript */
}; };
static PyMethodDef index_methods[] = { static PyMethodDef index_methods[] = {
{"ancestors", (PyCFunction)index_ancestors, METH_VARARGS, {"ancestors", (PyCFunction)index_ancestors, METH_VARARGS,
"return the gca set of the given revs"}, "return the gca set of the given revs"},
{"commonancestorsheads", (PyCFunction)index_commonancestorsheads, {"commonancestorsheads", (PyCFunction)index_commonancestorsheads,
METH_VARARGS, METH_VARARGS,
"return the heads of the common ancestors of the given revs"}, "return the heads of the common ancestors of the given revs"},
{"clearcaches", (PyCFunction)index_clearcaches, METH_NOARGS, {"clearcaches", (PyCFunction)index_clearcaches, METH_NOARGS,
"clear the index caches"}, "clear the index caches"},
{"get", (PyCFunction)index_m_get, METH_VARARGS, {"get", (PyCFunction)index_m_get, METH_VARARGS, "get an index entry"},
"get an index entry"}, {"computephasesmapsets", (PyCFunction)compute_phases_map_sets, METH_VARARGS,
{"computephasesmapsets", (PyCFunction)compute_phases_map_sets, "compute phases"},
METH_VARARGS, "compute phases"},
{"reachableroots2", (PyCFunction)reachableroots2, METH_VARARGS, {"reachableroots2", (PyCFunction)reachableroots2, METH_VARARGS,
"reachableroots"}, "reachableroots"},
{"headrevs", (PyCFunction)index_headrevs, METH_VARARGS, {"headrevs", (PyCFunction)index_headrevs, METH_VARARGS,
"get head revisions"}, /* Can do filtering since 3.2 */ "get head revisions"}, /* Can do filtering since 3.2 */
{"headrevsfiltered", (PyCFunction)index_headrevs, METH_VARARGS, {"headrevsfiltered", (PyCFunction)index_headrevs, METH_VARARGS,
"get filtered head revisions"}, /* Can always do filtering */ "get filtered head revisions"}, /* Can always do filtering */
{"deltachain", (PyCFunction)index_deltachain, METH_VARARGS, {"deltachain", (PyCFunction)index_deltachain, METH_VARARGS,
"determine revisions with deltas to reconstruct fulltext"}, "determine revisions with deltas to reconstruct fulltext"},
{"append", (PyCFunction)index_append, METH_O, {"append", (PyCFunction)index_append, METH_O, "append an index entry"},
"append an index entry"},
{"partialmatch", (PyCFunction)index_partialmatch, METH_VARARGS, {"partialmatch", (PyCFunction)index_partialmatch, METH_VARARGS,
"match a potentially ambiguous node ID"}, "match a potentially ambiguous node ID"},
{"shortest", (PyCFunction)index_shortest, METH_VARARGS, {"shortest", (PyCFunction)index_shortest, METH_VARARGS,
"find length of shortest hex nodeid of a binary ID"}, "find length of shortest hex nodeid of a binary ID"},
{"stats", (PyCFunction)index_stats, METH_NOARGS, {"stats", (PyCFunction)index_stats, METH_NOARGS, "stats for the index"},
"stats for the index"},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyGetSetDef index_getset[] = { static PyGetSetDef index_getset[] = {
{"nodemap", (getter)index_nodemap, NULL, "nodemap", NULL}, {"nodemap", (getter)index_nodemap, NULL, "nodemap", NULL},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyTypeObject indexType = { static PyTypeObject indexType = {
PyVarObject_HEAD_INIT(NULL, 0) /* header */ PyVarObject_HEAD_INIT(NULL, 0) /* header */
"parsers.index", /* tp_name */ "parsers.index", /* tp_name */
sizeof(indexObject), /* tp_basicsize */ sizeof(indexObject), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
(destructor)index_dealloc, /* tp_dealloc */ (destructor)index_dealloc, /* tp_dealloc */
0, /* tp_print */ 0, /* tp_print */
0, /* tp_getattr */ 0, /* tp_getattr */
0, /* tp_setattr */ 0, /* tp_setattr */
0, /* tp_compare */ 0, /* tp_compare */
0, /* tp_repr */ 0, /* tp_repr */
0, /* tp_as_number */ 0, /* tp_as_number */
&index_sequence_methods, /* tp_as_sequence */ &index_sequence_methods, /* tp_as_sequence */
&index_mapping_methods, /* tp_as_mapping */ &index_mapping_methods, /* tp_as_mapping */
0, /* tp_hash */ 0, /* tp_hash */
0, /* tp_call */ 0, /* tp_call */
0, /* tp_str */ 0, /* tp_str */
0, /* tp_getattro */ 0, /* tp_getattro */
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */ Py_TPFLAGS_DEFAULT, /* tp_flags */
"revlog index", /* tp_doc */ "revlog index", /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
0, /* tp_weaklistoffset */ 0, /* tp_weaklistoffset */
0, /* tp_iter */ 0, /* tp_iter */
0, /* tp_iternext */ 0, /* tp_iternext */
index_methods, /* tp_methods */ index_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
index_getset, /* tp_getset */ index_getset, /* tp_getset */
0, /* tp_base */ 0, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)index_init, /* tp_init */ (initproc)index_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
}; };
/* /*
* returns a tuple of the form (index, index, cache) with elements as * returns a tuple of the form (index, index, cache) with elements as
* follows: * follows:
* *
* index: an index object that lazily parses RevlogNG records * index: an index object that lazily parses RevlogNG records
* cache: if data is inlined, a tuple (0, index_file_content), else None * cache: if data is inlined, a tuple (0, index_file_content), else None
/* rustlazyancestors: iteration over ancestors implemented in Rust /* rustlazyancestors: iteration over ancestors implemented in Rust
* *
* This class holds a reference to an index and to the Rust iterator. * This class holds a reference to an index and to the Rust iterator.
*/ */
typedef struct rustlazyancestorsObjectStruct rustlazyancestorsObject; typedef struct rustlazyancestorsObjectStruct rustlazyancestorsObject;
struct rustlazyancestorsObjectStruct { struct rustlazyancestorsObjectStruct {
PyObject_HEAD PyObject_HEAD
/* Type-specific fields go here. */ /* Type-specific fields go here. */
indexObject *index; /* Ref kept to avoid GC'ing the index */ indexObject *index; /* Ref kept to avoid GC'ing the index */
void *iter; /* Rust iterator */ void *iter; /* Rust iterator */
}; };
/* FFI exposed from Rust code */ /* FFI exposed from Rust code */
rustlazyancestorsObject *rustlazyancestors_init( rustlazyancestorsObject *
indexObject *index, rustlazyancestors_init(indexObject *index,
/* to pass index_get_parents() */ /* to pass index_get_parents() */
int (*)(indexObject *, Py_ssize_t, int*, int), int (*)(indexObject *, Py_ssize_t, int *, int),
/* intrevs vector */ /* intrevs vector */
Py_ssize_t initrevslen, long *initrevs, Py_ssize_t initrevslen, long *initrevs, long stoprev,
long stoprev,
int inclusive); int inclusive);
void rustlazyancestors_drop(rustlazyancestorsObject *self); void rustlazyancestors_drop(rustlazyancestorsObject *self);
int rustlazyancestors_next(rustlazyancestorsObject *self); int rustlazyancestors_next(rustlazyancestorsObject *self);
int rustlazyancestors_contains(rustlazyancestorsObject *self, long rev); int rustlazyancestors_contains(rustlazyancestorsObject *self, long rev);
/* CPython instance methods */ /* CPython instance methods */
static int rustla_init(rustlazyancestorsObject *self, static int rustla_init(rustlazyancestorsObject *self, PyObject *args)
PyObject *args) { {
PyObject *initrevsarg = NULL; PyObject *initrevsarg = NULL;
PyObject *inclusivearg = NULL; PyObject *inclusivearg = NULL;
long stoprev = 0; long stoprev = 0;
long *initrevs = NULL; long *initrevs = NULL;
int inclusive = 0; int inclusive = 0;
Py_ssize_t i; Py_ssize_t i;
indexObject *index; indexObject *index;
if (!PyArg_ParseTuple(args, "O!O!lO!", if (!PyArg_ParseTuple(args, "O!O!lO!", &indexType, &index, &PyList_Type,
&indexType, &index, &initrevsarg, &stoprev, &PyBool_Type,
&PyList_Type, &initrevsarg, &inclusivearg))
&stoprev,
&PyBool_Type, &inclusivearg))
return -1; return -1;
Py_INCREF(index); Py_INCREF(index);
self->index = index; self->index = index;
if (inclusivearg == Py_True) if (inclusivearg == Py_True)
inclusive = 1; inclusive = 1;
Py_ssize_t linit = PyList_GET_SIZE(initrevsarg); Py_ssize_t linit = PyList_GET_SIZE(initrevsarg);
initrevs = (long*)calloc(linit, sizeof(long)); initrevs = (long *)calloc(linit, sizeof(long));
if (initrevs == NULL) { if (initrevs == NULL) {
PyErr_NoMemory(); PyErr_NoMemory();
goto bail; goto bail;
} }
for (i=0; i<linit; i++) { for (i = 0; i < linit; i++) {
initrevs[i] = PyInt_AsLong(PyList_GET_ITEM(initrevsarg, i)); initrevs[i] = PyInt_AsLong(PyList_GET_ITEM(initrevsarg, i));
} }
if (PyErr_Occurred()) if (PyErr_Occurred())
goto bail; goto bail;
self->iter = rustlazyancestors_init(index, self->iter = rustlazyancestors_init(index, index_get_parents, linit,
index_get_parents, initrevs, stoprev, inclusive);
linit, initrevs,
stoprev, inclusive);
if (self->iter == NULL) { if (self->iter == NULL) {
/* if this is because of GraphError::ParentOutOfRange /* if this is because of GraphError::ParentOutOfRange
* index_get_parents() has already set the proper ValueError */ * index_get_parents() has already set the proper ValueError */
goto bail; goto bail;
} }
free(initrevs); free(initrevs);
return 0; return 0;
bail: bail:
free(initrevs); free(initrevs);
return -1; return -1;
}; };
static void rustla_dealloc(rustlazyancestorsObject *self) static void rustla_dealloc(rustlazyancestorsObject *self)
{ {
Py_XDECREF(self->index); Py_XDECREF(self->index);
if (self->iter != NULL) { /* can happen if rustla_init failed */ if (self->iter != NULL) { /* can happen if rustla_init failed */
rustlazyancestors_drop(self->iter); rustlazyancestors_drop(self->iter);
} }
PyObject_Del(self); PyObject_Del(self);
} }
static PyObject *rustla_next(rustlazyancestorsObject *self) { static PyObject *rustla_next(rustlazyancestorsObject *self)
{
int res = rustlazyancestors_next(self->iter); int res = rustlazyancestors_next(self->iter);
if (res == -1) { if (res == -1) {
/* Setting an explicit exception seems unnecessary /* Setting an explicit exception seems unnecessary
* as examples from Python source code (Objects/rangeobjets.c and * as examples from Python source code (Objects/rangeobjets.c
* Modules/_io/stringio.c) seem to demonstrate. * and Modules/_io/stringio.c) seem to demonstrate.
*/ */
return NULL; return NULL;
} }
return PyInt_FromLong(res); return PyInt_FromLong(res);
} }
static int rustla_contains(rustlazyancestorsObject *self, PyObject *rev) { static int rustla_contains(rustlazyancestorsObject *self, PyObject *rev)
{
if (!(PyInt_Check(rev))) { if (!(PyInt_Check(rev))) {
return 0; return 0;
} }
return rustlazyancestors_contains(self->iter, PyInt_AS_LONG(rev)); return rustlazyancestors_contains(self->iter, PyInt_AS_LONG(rev));
} }
static PySequenceMethods rustla_sequence_methods = { static PySequenceMethods rustla_sequence_methods = {
0, /* sq_length */ 0, /* sq_length */
0, /* sq_concat */ 0, /* sq_concat */
0, /* sq_repeat */ 0, /* sq_repeat */
0, /* sq_item */ 0, /* sq_item */
0, /* sq_slice */ 0, /* sq_slice */
0, /* sq_ass_item */ 0, /* sq_ass_item */
0, /* sq_ass_slice */ 0, /* sq_ass_slice */
(objobjproc)rustla_contains, /* sq_contains */ (objobjproc)rustla_contains, /* sq_contains */
}; };
static PyTypeObject rustlazyancestorsType = { static PyTypeObject rustlazyancestorsType = {
PyVarObject_HEAD_INIT(NULL, 0) /* header */ PyVarObject_HEAD_INIT(NULL, 0) /* header */
"parsers.rustlazyancestors", /* tp_name */ "parsers.rustlazyancestors", /* tp_name */
sizeof(rustlazyancestorsObject), /* tp_basicsize */ sizeof(rustlazyancestorsObject), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
(destructor)rustla_dealloc, /* tp_dealloc */ (destructor)rustla_dealloc, /* tp_dealloc */
0, /* tp_print */ 0, /* tp_print */
0, /* tp_getattr */ 0, /* tp_getattr */
0, /* tp_setattr */ 0, /* tp_setattr */
0, /* tp_compare */ 0, /* tp_compare */
0, /* tp_repr */ 0, /* tp_repr */
0, /* tp_as_number */ 0, /* tp_as_number */
&rustla_sequence_methods, /* tp_as_sequence */ &rustla_sequence_methods, /* tp_as_sequence */
0, /* tp_as_mapping */ 0, /* tp_as_mapping */
0, /* tp_hash */ 0, /* tp_hash */
0, /* tp_call */ 0, /* tp_call */
0, /* tp_str */ 0, /* tp_str */
0, /* tp_getattro */ 0, /* tp_getattro */
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */ Py_TPFLAGS_DEFAULT, /* tp_flags */
"Iterator over ancestors, implemented in Rust", /* tp_doc */ "Iterator over ancestors, implemented in Rust", /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
0, /* tp_weaklistoffset */ 0, /* tp_weaklistoffset */
0, /* tp_iter */ 0, /* tp_iter */
(iternextfunc)rustla_next, /* tp_iternext */ (iternextfunc)rustla_next, /* tp_iternext */
0, /* tp_methods */ 0, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ 0, /* tp_getset */
0, /* tp_base */ 0, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
(initproc)rustla_init, /* tp_init */ (initproc)rustla_init, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
}; };
#endif /* WITH_RUST */ #endif /* WITH_RUST */
void revlog_module_init(PyObject *mod) void revlog_module_init(PyObject *mod)
{ {
indexType.tp_new = PyType_GenericNew; indexType.tp_new = PyType_GenericNew;
if (PyType_Ready(&indexType) < 0) if (PyType_Ready(&indexType) < 0)
return; return;
Py_INCREF(&indexType); Py_INCREF(&indexType);
PyModule_AddObject(mod, "index", (PyObject *)&indexType); PyModule_AddObject(mod, "index", (PyObject *)&indexType);
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) { if (!nullentry) {
nullentry = Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0, 0, nullentry = Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0,
-1, -1, -1, -1, nullid, 20); 0, -1, -1, -1, -1, nullid, 20);
} }
if (nullentry) if (nullentry)
PyObject_GC_UnTrack(nullentry); PyObject_GC_UnTrack(nullentry);
#ifdef WITH_RUST #ifdef WITH_RUST
rustlazyancestorsType.tp_new = PyType_GenericNew; rustlazyancestorsType.tp_new = PyType_GenericNew;
if (PyType_Ready(&rustlazyancestorsType) < 0) if (PyType_Ready(&rustlazyancestorsType) < 0)
return; return;
Py_INCREF(&rustlazyancestorsType); Py_INCREF(&rustlazyancestorsType);
PyModule_AddObject(mod, "rustlazyancestors", PyModule_AddObject(mod, "rustlazyancestors",
(PyObject *)&rustlazyancestorsType); (PyObject *)&rustlazyancestorsType);
#endif #endif
} }