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
Lint Skipped
Unit
Unit Tests Skipped

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 12457

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
} }