mercurial-scm/hg: mercurial/cext/revlog.c annotate

annotate mercurial/cext/revlog.c @ 44066:f5d2720f3bea

revlog-native: introduced ABI version in capsule Concerns that an inconsistency could arise between the actual contents of the capsule in revlog.c and the Rust consumer have been raised after the switch to the array of data and function pointers in f384d68d8ea8. It has been suggested that the `version` from parsers.c could be use for this. In this change, we introduce instead a separate ABI version number, which should have the following advantages: - no need to change the consuming Rust code for changes that have nothing to do with the contents of the capsule - the version number in parsers.c is not explicitely flagged as ABI. It's not obvious to me whether an ABI change that would be invisible to Python would warrant an increment The drawback is that developers now have to consider two version numbers. We expect the added cost of the check to be negligible because it occurs at instantiation of `CIndex` only, which in turn is tied to instantiation of Python objects such as `LazyAncestors` and `MixedIndex`. Frequent calls to `Cindex::new` should also probably hit the CPU branch predictor. Differential Revision: https://phab.mercurial-scm.org/D7856

author	Georges Racinet <georges.racinet@octobus.net>
date	Tue, 14 Jan 2020 12:04:12 +0100
parents	f384d68d8ea8
children	9db11679f8ac 864e9534d3d4

rev	line source
6389 0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	1 /*
0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	2 parsers.c - efficient content parsing
0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	3
0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	4 Copyright 2008 Matt Mackall <mpm@selenic.com> and others
0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	5
0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	6 This software may be used and distributed according to the terms of
0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	7 the GNU General Public License, incorporated herein by reference.
0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	8 */
0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	9
42067 b01bbb8ff1f2 cext: make revlog.c PY_SSIZE_T_CLEAN Gregory Szorc <gregory.szorc@gmail.com> parents: 41283 diff changeset	10 #define PY_SSIZE_T_CLEAN
6389 0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	11 #include <Python.h>
33174 f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	12 #include <assert.h>
6389 0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	13 #include <ctype.h>
40704 7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	14 #include <limits.h>
17356 511dfb34b412 parsers: fix an integer size warning issued by clang Bryan O'Sullivan <bryano@fb.com> parents: 17353 diff changeset	15 #include <stddef.h>
40707 cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	16 #include <stdlib.h>
6389 0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	17 #include <string.h>
0231f763ebc8 manifest: improve parsing performance by 8x via a new C extension Bryan O'Sullivan <bos@serpentine.com> parents: diff changeset	18
34438 b90e8da190da cext: reorder #include Gregory Szorc <gregory.szorc@gmail.com> parents: 34437 diff changeset	19 #include "bitmanipulation.h"
33758 0f4ac3b6dee4 cext: factor out header for charencode.c Yuya Nishihara <yuya@tcha.org> parents: 33475 diff changeset	20 #include "charencode.h"
40859 aa76be85029b revlog: export symbol of indexType Yuya Nishihara <yuya@tcha.org> parents: 40819 diff changeset	21 #include "revlog.h"
11361 3de3d670d2b6 parsers.c: Added support for py3k. Renato Cunha <renatoc@gmail.com> parents: 10449 diff changeset	22 #include "util.h"
3de3d670d2b6 parsers.c: Added support for py3k. Renato Cunha <renatoc@gmail.com> parents: 10449 diff changeset	23
30112 9b6ff0f940ed parsers: move PyInt aliasing out of util.h Gregory Szorc <gregory.szorc@gmail.com> parents: 30103 diff changeset	24 #ifdef IS_PY3K
9b6ff0f940ed parsers: move PyInt aliasing out of util.h Gregory Szorc <gregory.szorc@gmail.com> parents: 30103 diff changeset	25 /* The mapping of Python types is meant to be temporary to get Python
9b6ff0f940ed parsers: move PyInt aliasing out of util.h Gregory Szorc <gregory.szorc@gmail.com> parents: 30103 diff changeset	26 * 3 to compile. We should remove this once Python 3 support is fully
9b6ff0f940ed parsers: move PyInt aliasing out of util.h Gregory Szorc <gregory.szorc@gmail.com> parents: 30103 diff changeset	27 * supported and proper types are used in the extensions themselves. */
30169 5f7151e6de85 parsers: alias more PyInt* symbols on Python 3 Gregory Szorc <gregory.szorc@gmail.com> parents: 30112 diff changeset	28 #define PyInt_Check PyLong_Check
30112 9b6ff0f940ed parsers: move PyInt aliasing out of util.h Gregory Szorc <gregory.szorc@gmail.com> parents: 30103 diff changeset	29 #define PyInt_FromLong PyLong_FromLong
30169 5f7151e6de85 parsers: alias more PyInt* symbols on Python 3 Gregory Szorc <gregory.szorc@gmail.com> parents: 30112 diff changeset	30 #define PyInt_FromSsize_t PyLong_FromSsize_t
30112 9b6ff0f940ed parsers: move PyInt aliasing out of util.h Gregory Szorc <gregory.szorc@gmail.com> parents: 30103 diff changeset	31 #define PyInt_AsLong PyLong_AsLong
9b6ff0f940ed parsers: move PyInt aliasing out of util.h Gregory Szorc <gregory.szorc@gmail.com> parents: 30103 diff changeset	32 #endif
9b6ff0f940ed parsers: move PyInt aliasing out of util.h Gregory Szorc <gregory.szorc@gmail.com> parents: 30103 diff changeset	33
38939 53bc73fae1a3 index: add pointer from nodetree back to index Martin von Zweigbergk <martinvonz@google.com> parents: 38938 diff changeset	34 typedef struct indexObjectStruct indexObject;
53bc73fae1a3 index: add pointer from nodetree back to index Martin von Zweigbergk <martinvonz@google.com> parents: 38938 diff changeset	35
38912 d1bc0e7c862b index: extract a type for the nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38911 diff changeset	36 typedef struct {
d1bc0e7c862b index: extract a type for the nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38911 diff changeset	37 int children[16];
d1bc0e7c862b index: extract a type for the nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38911 diff changeset	38 } nodetreenode;
d1bc0e7c862b index: extract a type for the nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38911 diff changeset	39
43959 f384d68d8ea8 revlog: made C Capsule an array of function pointers Georges Racinet <georges.racinet@octobus.net> parents: 43847 diff changeset	40 typedef struct {
44066 f5d2720f3bea revlog-native: introduced ABI version in capsule Georges Racinet <georges.racinet@octobus.net> parents: 43959 diff changeset	41 int abi_version;
43959 f384d68d8ea8 revlog: made C Capsule an array of function pointers Georges Racinet <georges.racinet@octobus.net> parents: 43847 diff changeset	42 int (index_parents)(PyObject , int, int *);
f384d68d8ea8 revlog: made C Capsule an array of function pointers Georges Racinet <georges.racinet@octobus.net> parents: 43847 diff changeset	43 } Revlog_CAPI;
f384d68d8ea8 revlog: made C Capsule an array of function pointers Georges Racinet <georges.racinet@octobus.net> parents: 43847 diff changeset	44
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	45 /*
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	46 * A base-16 trie for fast node->rev mapping.
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	47 *
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	48 * Positive value is index of the next node in the trie
38846 f738c502e43b index: store nullrev as -1 in nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38845 diff changeset	49 * Negative value is a leaf: -(rev + 2)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	50 * Zero is empty
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	51 */
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	52 typedef struct {
38939 53bc73fae1a3 index: add pointer from nodetree back to index Martin von Zweigbergk <martinvonz@google.com> parents: 38938 diff changeset	53 indexObject *index;
38912 d1bc0e7c862b index: extract a type for the nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38911 diff changeset	54 nodetreenode *nodes;
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	55 unsigned length; /* # nodes in use */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	56 unsigned capacity; /* # nodes allocated */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	57 int depth; /* maximum depth of tree */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	58 int splits; /* # splits performed */
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	59 } nodetree;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	60
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	61 typedef struct {
40560 8c1f36bf2d3e revlog: add a comment to help clang-format produce less-awful results Augie Fackler <augie@google.com> parents: 40460 diff changeset	62 PyObject_HEAD /* ; */
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	63 nodetree nt;
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	64 } nodetreeObject;
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	65
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	66 /*
26098 ce26928cbe41 spelling: behaviour -> behavior timeless@mozdev.org parents: 26080 diff changeset	67 * This class has two behaviors.
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	68 *
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	69 * When used in a list-like way (with integer keys), we decode an
43582 ae5e39512ca0 revlog: delete references to deleted nullid sentinel value Martin von Zweigbergk <martinvonz@google.com> parents: 43554 diff changeset	70 * entry in a RevlogNG index file on demand. We have limited support for
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	71 * integer-keyed insert and delete, only at elements right before the
43582 ae5e39512ca0 revlog: delete references to deleted nullid sentinel value Martin von Zweigbergk <martinvonz@google.com> parents: 43554 diff changeset	72 * end.
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	73 *
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	74 * With string keys, we lazily perform a reverse mapping from node to
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	75 * rev, using a base-16 trie.
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	76 */
38939 53bc73fae1a3 index: add pointer from nodetree back to index Martin von Zweigbergk <martinvonz@google.com> parents: 38938 diff changeset	77 struct indexObjectStruct {
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	78 PyObject_HEAD
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	79 /* Type-specific fields go here. */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	80 PyObject data; / raw bytes of index */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	81 Py_buffer buf; /* buffer of data */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	82 PyObject *cache; / cached tuples */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	83 const char *offsets; / populated on demand */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	84 Py_ssize_t raw_length; /* original number of elements */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	85 Py_ssize_t length; /* current number of elements */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	86 PyObject added; / populated on demand */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	87 PyObject headrevs; / cache, invalidated on changes */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	88 PyObject filteredrevs; / filtered revs set */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	89 nodetree nt; /* base-16 trie */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	90 int ntinitialized; /* 0 or 1 */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	91 int ntrev; /* last rev scanned */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	92 int ntlookups; /* # lookups */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	93 int ntmisses; /* # lookups that miss the cache */
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	94 int inlined;
38939 53bc73fae1a3 index: add pointer from nodetree back to index Martin von Zweigbergk <martinvonz@google.com> parents: 38938 diff changeset	95 };
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	96
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	97 static Py_ssize_t index_length(const indexObject *self)
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	98 {
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	99 if (self->added == NULL)
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	100 return self->length;
52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	101 return self->length + PyList_GET_SIZE(self->added);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	102 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	103
40099 994010b87534 revlog: explicitly initialize static variables Yuya Nishihara <yuya@tcha.org> parents: 40088 diff changeset	104 static PyObject *nullentry = NULL;
994010b87534 revlog: explicitly initialize static variables Yuya Nishihara <yuya@tcha.org> parents: 40088 diff changeset	105 static const char nullid[20] = {0};
40960 43974cd44967 revlog: introduce a constant for nullrev in `revlog.c` Boris Feld <boris.feld@octobus.net> parents: 40862 diff changeset	106 static const Py_ssize_t nullrev = -1;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	107
22401 9ba8a93e55f5 parsers: ensure correct return type for inline_scan Henrik Stuart <hg@hstuart.dk> parents: 22400 diff changeset	108 static Py_ssize_t inline_scan(indexObject self, const char *offsets);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	109
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	110 #if LONG_MAX == 0x7fffffffL
36621 4015b9248da0 cext: mark tuple_format as a constant Yuya Nishihara <yuya@tcha.org> parents: 36620 diff changeset	111 static const char *const tuple_format = PY23("Kiiiiiis#", "Kiiiiiiy#");
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	112 #else
36621 4015b9248da0 cext: mark tuple_format as a constant Yuya Nishihara <yuya@tcha.org> parents: 36620 diff changeset	113 static const char *const tuple_format = PY23("kiiiiiis#", "kiiiiiiy#");
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	114 #endif
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	115
16863 bbedef66c6f3 parsers: replace magic number 64 with symbolic constant Bryan O'Sullivan <bryano@fb.com> parents: 16787 diff changeset	116 /* A RevlogNG v1 index entry is 64 bytes long. */
bbedef66c6f3 parsers: replace magic number 64 with symbolic constant Bryan O'Sullivan <bryano@fb.com> parents: 16787 diff changeset	117 static const long v1_hdrsize = 64;
bbedef66c6f3 parsers: replace magic number 64 with symbolic constant Bryan O'Sullivan <bryano@fb.com> parents: 16787 diff changeset	118
39219 f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	119 static void raise_revlog_error(void)
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	120 {
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	121 PyObject mod = NULL, dict = NULL, *errclass = NULL;
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	122
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	123 mod = PyImport_ImportModule("mercurial.error");
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	124 if (mod == NULL) {
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	125 goto cleanup;
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	126 }
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	127
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	128 dict = PyModule_GetDict(mod);
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	129 if (dict == NULL) {
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	130 goto cleanup;
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	131 }
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	132 Py_INCREF(dict);
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	133
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	134 errclass = PyDict_GetItemString(dict, "RevlogError");
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	135 if (errclass == NULL) {
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	136 PyErr_SetString(PyExc_SystemError,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	137 "could not find RevlogError");
39219 f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	138 goto cleanup;
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	139 }
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	140
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	141 /* value of exception is ignored by callers */
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	142 PyErr_SetString(errclass, "RevlogError");
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	143
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	144 cleanup:
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	145 Py_XDECREF(dict);
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	146 Py_XDECREF(mod);
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	147 }
f85b25608252 index: move raise_revlog_error() further up Martin von Zweigbergk <martinvonz@google.com> parents: 39218 diff changeset	148
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	149 /*
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	150 * Return a pointer to the beginning of a RevlogNG record.
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	151 */
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	152 static const char index_deref(indexObject self, Py_ssize_t pos)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	153 {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	154 if (self->inlined && pos > 0) {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	155 if (self->offsets == NULL) {
31470 bc445c556d3c parsers: use Python memory allocator for indexObject->offsets Gregory Szorc <gregory.szorc@gmail.com> parents: 31469 diff changeset	156 self->offsets = PyMem_Malloc(self->raw_length *
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	157 sizeof(*self->offsets));
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	158 if (self->offsets == NULL)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	159 return (const char *)PyErr_NoMemory();
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	160 inline_scan(self, self->offsets);
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	161 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	162 return self->offsets[pos];
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	163 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	164
30577 6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	165 return (const char )(self->buf.buf) + pos v1_hdrsize;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	166 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	167
40812 9cdd525d97b2 revlog: fix out-of-bounds access by negative parents read from revlog (SEC) Yuya Nishihara <yuya@tcha.org> parents: 40454 diff changeset	168 /*
9cdd525d97b2 revlog: fix out-of-bounds access by negative parents read from revlog (SEC) Yuya Nishihara <yuya@tcha.org> parents: 40454 diff changeset	169 * Get parents of the given rev.
9cdd525d97b2 revlog: fix out-of-bounds access by negative parents read from revlog (SEC) Yuya Nishihara <yuya@tcha.org> parents: 40454 diff changeset	170 *
9cdd525d97b2 revlog: fix out-of-bounds access by negative parents read from revlog (SEC) Yuya Nishihara <yuya@tcha.org> parents: 40454 diff changeset	171 * The specified rev must be valid and must not be nullrev. A returned
9cdd525d97b2 revlog: fix out-of-bounds access by negative parents read from revlog (SEC) Yuya Nishihara <yuya@tcha.org> parents: 40454 diff changeset	172 * parent revision may be nullrev, but is guaranteed to be in valid range.
9cdd525d97b2 revlog: fix out-of-bounds access by negative parents read from revlog (SEC) Yuya Nishihara <yuya@tcha.org> parents: 40454 diff changeset	173 */
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	174 static inline int index_get_parents(indexObject self, Py_ssize_t rev, int ps,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	175 int maxrev)
25311 d2e88f960d1a parsers: move index_get_parents's declaration higher Laurent Charignon <lcharignon@fb.com> parents: 25297 diff changeset	176 {
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	177 if (rev >= self->length) {
40598 fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	178 long tmp;
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	179 PyObject *tuple =
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	180 PyList_GET_ITEM(self->added, rev - self->length);
40598 fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	181 if (!pylong_to_long(PyTuple_GET_ITEM(tuple, 5), &tmp)) {
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	182 return -1;
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	183 }
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	184 ps[0] = (int)tmp;
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	185 if (!pylong_to_long(PyTuple_GET_ITEM(tuple, 6), &tmp)) {
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	186 return -1;
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	187 }
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	188 ps[1] = (int)tmp;
25311 d2e88f960d1a parsers: move index_get_parents's declaration higher Laurent Charignon <lcharignon@fb.com> parents: 25297 diff changeset	189 } else {
d2e88f960d1a parsers: move index_get_parents's declaration higher Laurent Charignon <lcharignon@fb.com> parents: 25297 diff changeset	190 const char *data = index_deref(self, rev);
d2e88f960d1a parsers: move index_get_parents's declaration higher Laurent Charignon <lcharignon@fb.com> parents: 25297 diff changeset	191 ps[0] = getbe32(data + 24);
d2e88f960d1a parsers: move index_get_parents's declaration higher Laurent Charignon <lcharignon@fb.com> parents: 25297 diff changeset	192 ps[1] = getbe32(data + 28);
d2e88f960d1a parsers: move index_get_parents's declaration higher Laurent Charignon <lcharignon@fb.com> parents: 25297 diff changeset	193 }
25810 82d6a35cf432 parsers: fix buffer overflow by invalid parent revision read from revlog Yuya Nishihara <yuya@tcha.org> parents: 25584 diff changeset	194 /* If index file is corrupted, ps[] may point to invalid revisions. So
82d6a35cf432 parsers: fix buffer overflow by invalid parent revision read from revlog Yuya Nishihara <yuya@tcha.org> parents: 25584 diff changeset	195 * there is a risk of buffer overflow to trust them unconditionally. */
40812 9cdd525d97b2 revlog: fix out-of-bounds access by negative parents read from revlog (SEC) Yuya Nishihara <yuya@tcha.org> parents: 40454 diff changeset	196 if (ps[0] < -1 \|\| ps[0] > maxrev \|\| ps[1] < -1 \|\| ps[1] > maxrev) {
25810 82d6a35cf432 parsers: fix buffer overflow by invalid parent revision read from revlog Yuya Nishihara <yuya@tcha.org> parents: 25584 diff changeset	197 PyErr_SetString(PyExc_ValueError, "parent out of range");
82d6a35cf432 parsers: fix buffer overflow by invalid parent revision read from revlog Yuya Nishihara <yuya@tcha.org> parents: 25584 diff changeset	198 return -1;
82d6a35cf432 parsers: fix buffer overflow by invalid parent revision read from revlog Yuya Nishihara <yuya@tcha.org> parents: 25584 diff changeset	199 }
82d6a35cf432 parsers: fix buffer overflow by invalid parent revision read from revlog Yuya Nishihara <yuya@tcha.org> parents: 25584 diff changeset	200 return 0;
25311 d2e88f960d1a parsers: move index_get_parents's declaration higher Laurent Charignon <lcharignon@fb.com> parents: 25297 diff changeset	201 }
d2e88f960d1a parsers: move index_get_parents's declaration higher Laurent Charignon <lcharignon@fb.com> parents: 25297 diff changeset	202
40861 b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	203 /*
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	204 * Get parents of the given rev.
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	205 *
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	206 * If the specified rev is out of range, IndexError will be raised. If the
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	207 * revlog entry is corrupted, ValueError may be raised.
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	208 *
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	209 * Returns 0 on success or -1 on failure.
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	210 */
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	211 int HgRevlogIndex_GetParents(PyObject op, int rev, int ps)
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	212 {
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	213 int tiprev;
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	214 if (!op \|\| !HgRevlogIndex_Check(op) \|\| !ps) {
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	215 PyErr_BadInternalCall();
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	216 return -1;
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	217 }
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	218 tiprev = (int)index_length((indexObject *)op) - 1;
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	219 if (rev < -1 \|\| rev > tiprev) {
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	220 PyErr_Format(PyExc_IndexError, "rev out of range: %d", rev);
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	221 return -1;
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	222 } else if (rev == -1) {
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	223 ps[0] = ps[1] = -1;
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	224 return 0;
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	225 } else {
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	226 return index_get_parents((indexObject *)op, rev, ps, tiprev);
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	227 }
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	228 }
b12700dd261f revlog: add public CPython function to get parent revisions Yuya Nishihara <yuya@tcha.org> parents: 40860 diff changeset	229
40703 d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	230 static inline int64_t index_get_start(indexObject *self, Py_ssize_t rev)
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	231 {
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	232 uint64_t offset;
40961 b54727f82511 sparse-revlog: handle nullrev in index_get_start Boris Feld <boris.feld@octobus.net> parents: 40960 diff changeset	233 if (rev == nullrev) {
b54727f82511 sparse-revlog: handle nullrev in index_get_start Boris Feld <boris.feld@octobus.net> parents: 40960 diff changeset	234 return 0;
b54727f82511 sparse-revlog: handle nullrev in index_get_start Boris Feld <boris.feld@octobus.net> parents: 40960 diff changeset	235 }
40703 d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	236 if (rev >= self->length) {
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	237 PyObject *tuple;
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	238 PyObject *pylong;
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	239 PY_LONG_LONG tmp;
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	240 tuple = PyList_GET_ITEM(self->added, rev - self->length);
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	241 pylong = PyTuple_GET_ITEM(tuple, 0);
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	242 tmp = PyLong_AsLongLong(pylong);
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	243 if (tmp == -1 && PyErr_Occurred()) {
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	244 return -1;
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	245 }
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	246 if (tmp < 0) {
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	247 PyErr_Format(PyExc_OverflowError,
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	248 "revlog entry size out of bound (%lld)",
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	249 (long long)tmp);
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	250 return -1;
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	251 }
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	252 offset = (uint64_t)tmp;
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	253 } else {
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	254 const char *data = index_deref(self, rev);
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	255 offset = getbe32(data + 4);
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	256 if (rev == 0) {
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	257 /* mask out version number for the first entry */
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	258 offset &= 0xFFFF;
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	259 } else {
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	260 uint32_t offset_high = getbe32(data);
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	261 offset \|= ((uint64_t)offset_high) << 32;
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	262 }
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	263 }
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	264 return (int64_t)(offset >> 16);
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	265 }
d5b300ec2e89 sparse-revlog: add a `index_get_start` function in C Boris Feld <boris.feld@octobus.net> parents: 40598 diff changeset	266
40704 7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	267 static inline int index_get_length(indexObject *self, Py_ssize_t rev)
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	268 {
40962 c6939b353ebd sparse-revlog: handle nullrev in index_get_length Boris Feld <boris.feld@octobus.net> parents: 40961 diff changeset	269 if (rev == nullrev) {
c6939b353ebd sparse-revlog: handle nullrev in index_get_length Boris Feld <boris.feld@octobus.net> parents: 40961 diff changeset	270 return 0;
c6939b353ebd sparse-revlog: handle nullrev in index_get_length Boris Feld <boris.feld@octobus.net> parents: 40961 diff changeset	271 }
40704 7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	272 if (rev >= self->length) {
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	273 PyObject *tuple;
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	274 PyObject *pylong;
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	275 long ret;
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	276 tuple = PyList_GET_ITEM(self->added, rev - self->length);
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	277 pylong = PyTuple_GET_ITEM(tuple, 1);
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	278 ret = PyInt_AsLong(pylong);
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	279 if (ret == -1 && PyErr_Occurred()) {
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	280 return -1;
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	281 }
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	282 if (ret < 0 \|\| ret > (long)INT_MAX) {
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	283 PyErr_Format(PyExc_OverflowError,
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	284 "revlog entry size out of bound (%ld)",
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	285 ret);
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	286 return -1;
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	287 }
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	288 return (int)ret;
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	289 } else {
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	290 const char *data = index_deref(self, rev);
40741 959130631de3 revlog: properly detect corrupted revlog in `index_get_length` Boris Feld <boris.feld@octobus.net> parents: 40707 diff changeset	291 int tmp = (int)getbe32(data + 8);
959130631de3 revlog: properly detect corrupted revlog in `index_get_length` Boris Feld <boris.feld@octobus.net> parents: 40707 diff changeset	292 if (tmp < 0) {
959130631de3 revlog: properly detect corrupted revlog in `index_get_length` Boris Feld <boris.feld@octobus.net> parents: 40707 diff changeset	293 PyErr_Format(PyExc_OverflowError,
959130631de3 revlog: properly detect corrupted revlog in `index_get_length` Boris Feld <boris.feld@octobus.net> parents: 40707 diff changeset	294 "revlog entry size out of bound (%d)",
959130631de3 revlog: properly detect corrupted revlog in `index_get_length` Boris Feld <boris.feld@octobus.net> parents: 40707 diff changeset	295 tmp);
959130631de3 revlog: properly detect corrupted revlog in `index_get_length` Boris Feld <boris.feld@octobus.net> parents: 40707 diff changeset	296 return -1;
959130631de3 revlog: properly detect corrupted revlog in `index_get_length` Boris Feld <boris.feld@octobus.net> parents: 40707 diff changeset	297 }
959130631de3 revlog: properly detect corrupted revlog in `index_get_length` Boris Feld <boris.feld@octobus.net> parents: 40707 diff changeset	298 return tmp;
40704 7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	299 }
7da3729d4b45 sparse-revlog: add a `index_get_length` function in C Boris Feld <boris.feld@octobus.net> parents: 40703 diff changeset	300 }
25311 d2e88f960d1a parsers: move index_get_parents's declaration higher Laurent Charignon <lcharignon@fb.com> parents: 25297 diff changeset	301
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	302 /*
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	303 * RevlogNG format (all in big endian, data may be inlined):
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	304 * 6 bytes: offset
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	305 * 2 bytes: flags
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	306 * 4 bytes: compressed length
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	307 * 4 bytes: uncompressed length
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	308 * 4 bytes: base revision
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	309 * 4 bytes: link revision
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	310 * 4 bytes: parent 1 revision
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	311 * 4 bytes: parent 2 revision
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	312 * 32 bytes: nodeid (only 20 bytes used)
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	313 */
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	314 static PyObject index_get(indexObject self, Py_ssize_t pos)
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	315 {
7154 7fdf7a0a41b7 index parser: fix refcounting in case of errors, refactor Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7135 diff changeset	316 uint64_t offset_flags;
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	317 int comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2;
7154 7fdf7a0a41b7 index parser: fix refcounting in case of errors, refactor Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7135 diff changeset	318 const char *c_node_id;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	319 const char *data;
38868 0db50770f388 index: don't add 1 to length variables Martin von Zweigbergk <martinvonz@google.com> parents: 38867 diff changeset	320 Py_ssize_t length = index_length(self);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	321 PyObject *entry;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	322
40960 43974cd44967 revlog: introduce a constant for nullrev in `revlog.c` Boris Feld <boris.feld@octobus.net> parents: 40862 diff changeset	323 if (pos == nullrev) {
38847 f3d394ea17db index: handle index[-1] as nullid more explicitly Martin von Zweigbergk <martinvonz@google.com> parents: 38846 diff changeset	324 Py_INCREF(nullentry);
f3d394ea17db index: handle index[-1] as nullid more explicitly Martin von Zweigbergk <martinvonz@google.com> parents: 38846 diff changeset	325 return nullentry;
f3d394ea17db index: handle index[-1] as nullid more explicitly Martin von Zweigbergk <martinvonz@google.com> parents: 38846 diff changeset	326 }
f3d394ea17db index: handle index[-1] as nullid more explicitly Martin von Zweigbergk <martinvonz@google.com> parents: 38846 diff changeset	327
38868 0db50770f388 index: don't add 1 to length variables Martin von Zweigbergk <martinvonz@google.com> parents: 38867 diff changeset	328 if (pos < 0 \|\| pos >= length) {
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	329 PyErr_SetString(PyExc_IndexError, "revlog index out of range");
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	330 return NULL;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	331 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	332
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	333 if (pos >= self->length) {
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	334 PyObject *obj;
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	335 obj = PyList_GET_ITEM(self->added, pos - self->length);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	336 Py_INCREF(obj);
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	337 return obj;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	338 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	339
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	340 if (self->cache) {
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	341 if (self->cache[pos]) {
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	342 Py_INCREF(self->cache[pos]);
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	343 return self->cache[pos];
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	344 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	345 } else {
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	346 self->cache = calloc(self->raw_length, sizeof(PyObject *));
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	347 if (self->cache == NULL)
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	348 return PyErr_NoMemory();
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	349 }
7190 aecea6934fdd Some additional space/tab cleanups Thomas Arendsen Hein <thomas@intevation.de> parents: 7186 diff changeset	350
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	351 data = index_deref(self, pos);
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	352 if (data == NULL)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	353 return NULL;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	354
16437 d126a0d16856 util.h: replace ntohl/htonl with get/putbe32 Matt Mackall <mpm@selenic.com> parents: 16414 diff changeset	355 offset_flags = getbe32(data + 4);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	356 if (pos == 0) /* mask out version number for the first entry */
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	357 offset_flags &= 0xFFFF;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	358 else {
16437 d126a0d16856 util.h: replace ntohl/htonl with get/putbe32 Matt Mackall <mpm@selenic.com> parents: 16414 diff changeset	359 uint32_t offset_high = getbe32(data);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	360 offset_flags \|= ((uint64_t)offset_high) << 32;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	361 }
7154 7fdf7a0a41b7 index parser: fix refcounting in case of errors, refactor Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7135 diff changeset	362
16437 d126a0d16856 util.h: replace ntohl/htonl with get/putbe32 Matt Mackall <mpm@selenic.com> parents: 16414 diff changeset	363 comp_len = getbe32(data + 8);
d126a0d16856 util.h: replace ntohl/htonl with get/putbe32 Matt Mackall <mpm@selenic.com> parents: 16414 diff changeset	364 uncomp_len = getbe32(data + 12);
d126a0d16856 util.h: replace ntohl/htonl with get/putbe32 Matt Mackall <mpm@selenic.com> parents: 16414 diff changeset	365 base_rev = getbe32(data + 16);
d126a0d16856 util.h: replace ntohl/htonl with get/putbe32 Matt Mackall <mpm@selenic.com> parents: 16414 diff changeset	366 link_rev = getbe32(data + 20);
d126a0d16856 util.h: replace ntohl/htonl with get/putbe32 Matt Mackall <mpm@selenic.com> parents: 16414 diff changeset	367 parent_1 = getbe32(data + 24);
d126a0d16856 util.h: replace ntohl/htonl with get/putbe32 Matt Mackall <mpm@selenic.com> parents: 16414 diff changeset	368 parent_2 = getbe32(data + 28);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	369 c_node_id = data + 32;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	370
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	371 entry = Py_BuildValue(tuple_format, offset_flags, comp_len, uncomp_len,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	372 base_rev, link_rev, parent_1, parent_2, c_node_id,
42096 509a0477b3a6 cext: cast s# arguments of Py_BuildValue() to Py_ssize_t Yuya Nishihara <yuya@tcha.org> parents: 42067 diff changeset	373 (Py_ssize_t)20);
13254 5ef5eb1f3515 revlog: only build the nodemap on demand Matt Mackall <mpm@selenic.com> parents: 11361 diff changeset	374
19726 b3c8c6f2b5c1 parsers: use Py_INCREF safely Bryan O'Sullivan <bryano@fb.com> parents: 19725 diff changeset	375 if (entry) {
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	376 PyObject_GC_UnTrack(entry);
19726 b3c8c6f2b5c1 parsers: use Py_INCREF safely Bryan O'Sullivan <bryano@fb.com> parents: 19725 diff changeset	377 Py_INCREF(entry);
b3c8c6f2b5c1 parsers: use Py_INCREF safely Bryan O'Sullivan <bryano@fb.com> parents: 19725 diff changeset	378 }
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	379
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	380 self->cache[pos] = entry;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	381
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	382 return entry;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	383 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	384
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	385 /*
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	386 * Return the 20-byte SHA of the node corresponding to the given rev.
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	387 */
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	388 static const char index_node(indexObject self, Py_ssize_t pos)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	389 {
38868 0db50770f388 index: don't add 1 to length variables Martin von Zweigbergk <martinvonz@google.com> parents: 38867 diff changeset	390 Py_ssize_t length = index_length(self);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	391 const char *data;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	392
40960 43974cd44967 revlog: introduce a constant for nullrev in `revlog.c` Boris Feld <boris.feld@octobus.net> parents: 40862 diff changeset	393 if (pos == nullrev)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	394 return nullid;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	395
38868 0db50770f388 index: don't add 1 to length variables Martin von Zweigbergk <martinvonz@google.com> parents: 38867 diff changeset	396 if (pos >= length)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	397 return NULL;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	398
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	399 if (pos >= self->length) {
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	400 PyObject tuple, str;
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	401 tuple = PyList_GET_ITEM(self->added, pos - self->length);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	402 str = PyTuple_GetItem(tuple, 7);
30100 c5afe5531709 parsers: convert PyString* to PyBytes* Gregory Szorc <gregory.szorc@gmail.com> parents: 30090 diff changeset	403 return str ? PyBytes_AS_STRING(str) : NULL;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	404 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	405
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	406 data = index_deref(self, pos);
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	407 return data ? data + 32 : NULL;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	408 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	409
37860 a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	410 /*
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	411 * Return the 20-byte SHA of the node corresponding to the given rev. The
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	412 * rev is assumed to be existing. If not, an exception is set.
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	413 */
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	414 static const char index_node_existing(indexObject self, Py_ssize_t pos)
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	415 {
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	416 const char *node = index_node(self, pos);
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	417 if (node == NULL) {
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	418 PyErr_Format(PyExc_IndexError, "could not access rev %d",
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	419 (int)pos);
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	420 }
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	421 return node;
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	422 }
a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	423
38940 b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	424 static int nt_insert(nodetree self, const char node, int rev);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	425
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	426 static int node_check(PyObject obj, char *node)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	427 {
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	428 Py_ssize_t nodelen;
49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	429 if (PyBytes_AsStringAndSize(obj, node, &nodelen) == -1)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	430 return -1;
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	431 if (nodelen == 20)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	432 return 0;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	433 PyErr_SetString(PyExc_ValueError, "20-byte hash required");
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	434 return -1;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	435 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	436
38850 6104b203bec8 index: replace insert(-1, e) method by append(e) method Martin von Zweigbergk <martinvonz@google.com> parents: 38848 diff changeset	437 static PyObject index_append(indexObject self, PyObject *obj)
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	438 {
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	439 char *node;
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	440 Py_ssize_t len;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	441
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	442 if (!PyTuple_Check(obj) \|\| PyTuple_GET_SIZE(obj) != 8) {
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	443 PyErr_SetString(PyExc_TypeError, "8-tuple required");
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	444 return NULL;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	445 }
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	446
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	447 if (node_check(PyTuple_GET_ITEM(obj, 7), &node) == -1)
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	448 return NULL;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	449
38868 0db50770f388 index: don't add 1 to length variables Martin von Zweigbergk <martinvonz@google.com> parents: 38867 diff changeset	450 len = index_length(self);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	451
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	452 if (self->added == NULL) {
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	453 self->added = PyList_New(0);
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	454 if (self->added == NULL)
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	455 return NULL;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	456 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	457
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	458 if (PyList_Append(self->added, obj) == -1)
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	459 return NULL;
13254 5ef5eb1f3515 revlog: only build the nodemap on demand Matt Mackall <mpm@selenic.com> parents: 11361 diff changeset	460
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	461 if (self->ntinitialized)
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	462 nt_insert(&self->nt, node, (int)len);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	463
16787 bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	464 Py_CLEAR(self->headrevs);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	465 Py_RETURN_NONE;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	466 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	467
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	468 static PyObject index_stats(indexObject self)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	469 {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	470 PyObject *obj = PyDict_New();
40455 88702fd208ce py3: convert revlog stats to a dict of (bytes, int) pairs Yuya Nishihara <yuya@tcha.org> parents: 40300 diff changeset	471 PyObject *s = NULL;
23948 bd307b462ce2 parsers: avoid leaking several PyObjects in index_stats Augie Fackler <augie@google.com> parents: 23947 diff changeset	472 PyObject *t = NULL;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	473
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	474 if (obj == NULL)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	475 return NULL;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	476
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	477 #define istat(__n, __d) \
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	478 do { \
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	479 s = PyBytes_FromString(__d); \
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	480 t = PyInt_FromSsize_t(self->__n); \
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	481 if (!s \|\| !t) \
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	482 goto bail; \
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	483 if (PyDict_SetItem(obj, s, t) == -1) \
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	484 goto bail; \
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	485 Py_CLEAR(s); \
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	486 Py_CLEAR(t); \
28792 507136150d2b parsers: fix istat macro to work with single line if statement Matt Fowles <matt.fowles@gmail.com> parents: 28386 diff changeset	487 } while (0)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	488
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	489 if (self->added) {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	490 Py_ssize_t len = PyList_GET_SIZE(self->added);
40455 88702fd208ce py3: convert revlog stats to a dict of (bytes, int) pairs Yuya Nishihara <yuya@tcha.org> parents: 40300 diff changeset	491 s = PyBytes_FromString("index entries added");
23948 bd307b462ce2 parsers: avoid leaking several PyObjects in index_stats Augie Fackler <augie@google.com> parents: 23947 diff changeset	492 t = PyInt_FromSsize_t(len);
40455 88702fd208ce py3: convert revlog stats to a dict of (bytes, int) pairs Yuya Nishihara <yuya@tcha.org> parents: 40300 diff changeset	493 if (!s \|\| !t)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	494 goto bail;
40455 88702fd208ce py3: convert revlog stats to a dict of (bytes, int) pairs Yuya Nishihara <yuya@tcha.org> parents: 40300 diff changeset	495 if (PyDict_SetItem(obj, s, t) == -1)
23948 bd307b462ce2 parsers: avoid leaking several PyObjects in index_stats Augie Fackler <augie@google.com> parents: 23947 diff changeset	496 goto bail;
40455 88702fd208ce py3: convert revlog stats to a dict of (bytes, int) pairs Yuya Nishihara <yuya@tcha.org> parents: 40300 diff changeset	497 Py_CLEAR(s);
88702fd208ce py3: convert revlog stats to a dict of (bytes, int) pairs Yuya Nishihara <yuya@tcha.org> parents: 40300 diff changeset	498 Py_CLEAR(t);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	499 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	500
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	501 if (self->raw_length != self->length)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	502 istat(raw_length, "revs on disk");
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	503 istat(length, "revs in memory");
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	504 istat(ntlookups, "node trie lookups");
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	505 istat(ntmisses, "node trie misses");
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	506 istat(ntrev, "node trie last rev scanned");
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	507 if (self->ntinitialized) {
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	508 istat(nt.capacity, "node trie capacity");
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	509 istat(nt.depth, "node trie depth");
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	510 istat(nt.length, "node trie count");
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	511 istat(nt.splits, "node trie splits");
38913 c2c253558e3c index: move more fields onto nodetree type Martin von Zweigbergk <martinvonz@google.com> parents: 38912 diff changeset	512 }
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	513
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	514 #undef istat
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	515
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	516 return obj;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	517
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	518 bail:
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	519 Py_XDECREF(obj);
40455 88702fd208ce py3: convert revlog stats to a dict of (bytes, int) pairs Yuya Nishihara <yuya@tcha.org> parents: 40300 diff changeset	520 Py_XDECREF(s);
23948 bd307b462ce2 parsers: avoid leaking several PyObjects in index_stats Augie Fackler <augie@google.com> parents: 23947 diff changeset	521 Py_XDECREF(t);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	522 return NULL;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	523 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	524
16787 bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	525 /*
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	526 * When we cache a list, we want to be sure the caller can't mutate
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	527 * the cached copy.
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	528 */
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	529 static PyObject list_copy(PyObject list)
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	530 {
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	531 Py_ssize_t len = PyList_GET_SIZE(list);
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	532 PyObject *newlist = PyList_New(len);
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	533 Py_ssize_t i;
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	534
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	535 if (newlist == NULL)
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	536 return NULL;
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	537
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	538 for (i = 0; i < len; i++) {
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	539 PyObject *obj = PyList_GET_ITEM(list, i);
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	540 Py_INCREF(obj);
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	541 PyList_SET_ITEM(newlist, i, obj);
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	542 }
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	543
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	544 return newlist;
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	545 }
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	546
34440 7ed0750c71a1 cext: wrap before brace for functions Gregory Szorc <gregory.szorc@gmail.com> parents: 34438 diff changeset	547 static int check_filter(PyObject *filter, Py_ssize_t arg)
7ed0750c71a1 cext: wrap before brace for functions Gregory Szorc <gregory.szorc@gmail.com> parents: 34438 diff changeset	548 {
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	549 if (filter) {
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	550 PyObject arglist, result;
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	551 int isfiltered;
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	552
26107 50582df9d7a7 parsers: fix two cases of unsigned long instead of Py_ssize_t Augie Fackler <augie@google.com> parents: 26098 diff changeset	553 arglist = Py_BuildValue("(n)", arg);
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	554 if (!arglist) {
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	555 return -1;
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	556 }
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	557
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	558 result = PyEval_CallObject(filter, arglist);
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	559 Py_DECREF(arglist);
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	560 if (!result) {
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	561 return -1;
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	562 }
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	563
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	564 /* PyObject_IsTrue returns 1 if true, 0 if false, -1 if error,
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	565 * same as this function, so we can just return it directly.*/
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	566 isfiltered = PyObject_IsTrue(result);
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	567 Py_DECREF(result);
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	568 return isfiltered;
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	569 } else {
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	570 return 0;
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	571 }
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	572 }
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	573
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	574 static Py_ssize_t add_roots_get_min(indexObject self, PyObject list,
24499 90db70de6f9c parsers.c: avoid implicit conversion loses integer warnings Andr? Sintzoff <andre.sintzoff@gmail.com> parents: 24443 diff changeset	575 Py_ssize_t marker, char *phases)
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	576 {
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	577 PyObject *iter = NULL;
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	578 PyObject *iter_item = NULL;
38851 781b2720d2ac index: don't include nullid in len() Martin von Zweigbergk <martinvonz@google.com> parents: 38850 diff changeset	579 Py_ssize_t min_idx = index_length(self) + 2;
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	580 long iter_item_long;
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	581
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	582 if (PyList_GET_SIZE(list) != 0) {
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	583 iter = PyObject_GetIter(list);
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	584 if (iter == NULL)
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	585 return -2;
34437 ce26a13869fb cext: move braces for control statements to same line Gregory Szorc <gregory.szorc@gmail.com> parents: 33758 diff changeset	586 while ((iter_item = PyIter_Next(iter))) {
40598 fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	587 if (!pylong_to_long(iter_item, &iter_item_long)) {
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	588 Py_DECREF(iter_item);
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	589 return -2;
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	590 }
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	591 Py_DECREF(iter_item);
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	592 if (iter_item_long < min_idx)
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	593 min_idx = iter_item_long;
39228 66f046116105 cext: fix truncation warnings in revlog on Windows Matt Harbison <matt_harbison@yahoo.com> parents: 39227 diff changeset	594 phases[iter_item_long] = (char)marker;
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	595 }
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	596 Py_DECREF(iter);
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	597 }
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	598
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	599 return min_idx;
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	600 }
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	601
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	602 static inline void set_phase_from_parents(char *phases, int parent_1,
24499 90db70de6f9c parsers.c: avoid implicit conversion loses integer warnings Andr? Sintzoff <andre.sintzoff@gmail.com> parents: 24443 diff changeset	603 int parent_2, Py_ssize_t i)
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	604 {
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	605 if (parent_1 >= 0 && phases[parent_1] > phases[i])
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	606 phases[i] = phases[parent_1];
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	607 if (parent_2 >= 0 && phases[parent_2] > phases[i])
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	608 phases[i] = phases[parent_2];
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	609 }
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	610
26053 b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	611 static PyObject reachableroots2(indexObject self, PyObject *args)
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	612 {
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	613
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	614 /* Input */
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	615 long minroot;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	616 PyObject *includepatharg = NULL;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	617 int includepath = 0;
26053 b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	618 /* heads and roots are lists */
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	619 PyObject *heads = NULL;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	620 PyObject *roots = NULL;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	621 PyObject *reachable = NULL;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	622
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	623 PyObject *val;
38851 781b2720d2ac index: don't include nullid in len() Martin von Zweigbergk <martinvonz@google.com> parents: 38850 diff changeset	624 Py_ssize_t len = index_length(self);
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	625 long revnum;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	626 Py_ssize_t k;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	627 Py_ssize_t i;
26042 2a3010ba6f52 reachableroots: give anonymous name to short-lived "numheads" variable Yuya Nishihara <yuya@tcha.org> parents: 26041 diff changeset	628 Py_ssize_t l;
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	629 int r;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	630 int parents[2];
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	631
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	632 /* Internal data structure:
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	633 * tovisit: array of length len+1 (all revs + nullrev), filled upto
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	634 * lentovisit
40561 5c14bf0c5be3 revlog: add blank line in comment to help clang-format Augie Fackler <augie@google.com> parents: 40560 diff changeset	635 *
26044 b3ad349d0e50 reachableroots: extend "revstates" to array of bit flags Yuya Nishihara <yuya@tcha.org> parents: 26043 diff changeset	636 * revstates: array of length len+1 (all revs + nullrev) */
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	637 int *tovisit = NULL;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	638 long lentovisit = 0;
26054 5049e10fed14 reachableroots: use internal "revstates" array to test if rev is reachable Yuya Nishihara <yuya@tcha.org> parents: 26053 diff changeset	639 enum { RS_SEEN = 1, RS_ROOT = 2, RS_REACHABLE = 4 };
26043 f2f0a3ab6e41 reachableroots: rename "seen" array to "revstates" for future extension Yuya Nishihara <yuya@tcha.org> parents: 26042 diff changeset	640 char *revstates = NULL;
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	641
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	642 /* Get arguments */
26009 bbb698697efc reachableroots: fix transposition of set and list types in PyArg_ParseTuple Augie Fackler <augie@google.com> parents: 26008 diff changeset	643 if (!PyArg_ParseTuple(args, "lO!O!O!", &minroot, &PyList_Type, &heads,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	644 &PyList_Type, &roots, &PyBool_Type,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	645 &includepatharg))
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	646 goto bail;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	647
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	648 if (includepatharg == Py_True)
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	649 includepath = 1;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	650
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	651 /* Initialize return set */
26055 607868eccaa7 reachableroots: return list of revisions instead of set Yuya Nishihara <yuya@tcha.org> parents: 26054 diff changeset	652 reachable = PyList_New(0);
607868eccaa7 reachableroots: return list of revisions instead of set Yuya Nishihara <yuya@tcha.org> parents: 26054 diff changeset	653 if (reachable == NULL)
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	654 goto bail;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	655
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	656 /* Initialize internal datastructures */
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	657 tovisit = (int )malloc((len + 1) sizeof(int));
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	658 if (tovisit == NULL) {
26008 59d57ea69ae6 reachableroots: consistently use short-form of PyErr_NoMemory() Augie Fackler <augie@google.com> parents: 26007 diff changeset	659 PyErr_NoMemory();
26016 c8d41c9c23c7 reachableroots: unify bail cases to raise exception correctly Yuya Nishihara <yuya@tcha.org> parents: 26015 diff changeset	660 goto bail;
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	661 }
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	662
26043 f2f0a3ab6e41 reachableroots: rename "seen" array to "revstates" for future extension Yuya Nishihara <yuya@tcha.org> parents: 26042 diff changeset	663 revstates = (char *)calloc(len + 1, 1);
f2f0a3ab6e41 reachableroots: rename "seen" array to "revstates" for future extension Yuya Nishihara <yuya@tcha.org> parents: 26042 diff changeset	664 if (revstates == NULL) {
26008 59d57ea69ae6 reachableroots: consistently use short-form of PyErr_NoMemory() Augie Fackler <augie@google.com> parents: 26007 diff changeset	665 PyErr_NoMemory();
26016 c8d41c9c23c7 reachableroots: unify bail cases to raise exception correctly Yuya Nishihara <yuya@tcha.org> parents: 26015 diff changeset	666 goto bail;
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	667 }
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	668
26053 b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	669 l = PyList_GET_SIZE(roots);
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	670 for (i = 0; i < l; i++) {
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	671 revnum = PyInt_AsLong(PyList_GET_ITEM(roots, i));
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	672 if (revnum == -1 && PyErr_Occurred())
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	673 goto bail;
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	674 /* If root is out of range, e.g. wdir(), it must be unreachable
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	675 * from heads. So we can just ignore it. */
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	676 if (revnum + 1 < 0 \|\| revnum + 1 >= len + 1)
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	677 continue;
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	678 revstates[revnum + 1] \|= RS_ROOT;
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	679 }
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	680
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	681 /* Populate tovisit with all the heads */
26042 2a3010ba6f52 reachableroots: give anonymous name to short-lived "numheads" variable Yuya Nishihara <yuya@tcha.org> parents: 26041 diff changeset	682 l = PyList_GET_SIZE(heads);
2a3010ba6f52 reachableroots: give anonymous name to short-lived "numheads" variable Yuya Nishihara <yuya@tcha.org> parents: 26041 diff changeset	683 for (i = 0; i < l; i++) {
26018 c6115c30a376 reachableroots: verify type of each item of heads argument Yuya Nishihara <yuya@tcha.org> parents: 26017 diff changeset	684 revnum = PyInt_AsLong(PyList_GET_ITEM(heads, i));
c6115c30a376 reachableroots: verify type of each item of heads argument Yuya Nishihara <yuya@tcha.org> parents: 26017 diff changeset	685 if (revnum == -1 && PyErr_Occurred())
c6115c30a376 reachableroots: verify type of each item of heads argument Yuya Nishihara <yuya@tcha.org> parents: 26017 diff changeset	686 goto bail;
26017 44705659da94 reachableroots: verify integer range of heads argument (issue4775) Yuya Nishihara <yuya@tcha.org> parents: 26016 diff changeset	687 if (revnum + 1 < 0 \|\| revnum + 1 >= len + 1) {
44705659da94 reachableroots: verify integer range of heads argument (issue4775) Yuya Nishihara <yuya@tcha.org> parents: 26016 diff changeset	688 PyErr_SetString(PyExc_IndexError, "head out of range");
44705659da94 reachableroots: verify integer range of heads argument (issue4775) Yuya Nishihara <yuya@tcha.org> parents: 26016 diff changeset	689 goto bail;
44705659da94 reachableroots: verify integer range of heads argument (issue4775) Yuya Nishihara <yuya@tcha.org> parents: 26016 diff changeset	690 }
26044 b3ad349d0e50 reachableroots: extend "revstates" to array of bit flags Yuya Nishihara <yuya@tcha.org> parents: 26043 diff changeset	691 if (!(revstates[revnum + 1] & RS_SEEN)) {
26080 83c9edcac05c reachableroots: silence warning of implicit integer narrowing issued by clang Yuya Nishihara <yuya@tcha.org> parents: 26079 diff changeset	692 tovisit[lentovisit++] = (int)revnum;
26044 b3ad349d0e50 reachableroots: extend "revstates" to array of bit flags Yuya Nishihara <yuya@tcha.org> parents: 26043 diff changeset	693 revstates[revnum + 1] \|= RS_SEEN;
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	694 }
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	695 }
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	696
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	697 /* Visit the tovisit list and find the reachable roots */
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	698 k = 0;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	699 while (k < lentovisit) {
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	700 /* Add the node to reachable if it is a root*/
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	701 revnum = tovisit[k++];
26053 b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	702 if (revstates[revnum + 1] & RS_ROOT) {
26054 5049e10fed14 reachableroots: use internal "revstates" array to test if rev is reachable Yuya Nishihara <yuya@tcha.org> parents: 26053 diff changeset	703 revstates[revnum + 1] \|= RS_REACHABLE;
26053 b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	704 val = PyInt_FromLong(revnum);
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	705 if (val == NULL)
b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	706 goto bail;
26058 e7fe0a12376c reachableroots: handle error of PyList_Append() Yuya Nishihara <yuya@tcha.org> parents: 26055 diff changeset	707 r = PyList_Append(reachable, val);
26053 b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	708 Py_DECREF(val);
26058 e7fe0a12376c reachableroots: handle error of PyList_Append() Yuya Nishihara <yuya@tcha.org> parents: 26055 diff changeset	709 if (r < 0)
e7fe0a12376c reachableroots: handle error of PyList_Append() Yuya Nishihara <yuya@tcha.org> parents: 26055 diff changeset	710 goto bail;
26053 b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26052 diff changeset	711 if (includepath == 0)
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	712 continue;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	713 }
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	714
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	715 /* Add its parents to the list of nodes to visit */
40960 43974cd44967 revlog: introduce a constant for nullrev in `revlog.c` Boris Feld <boris.feld@octobus.net> parents: 40862 diff changeset	716 if (revnum == nullrev)
26041 8da628be211b reachableroots: reduce nesting level by jumping to next iteration by continue Yuya Nishihara <yuya@tcha.org> parents: 26033 diff changeset	717 continue;
8da628be211b reachableroots: reduce nesting level by jumping to next iteration by continue Yuya Nishihara <yuya@tcha.org> parents: 26033 diff changeset	718 r = index_get_parents(self, revnum, parents, (int)len - 1);
8da628be211b reachableroots: reduce nesting level by jumping to next iteration by continue Yuya Nishihara <yuya@tcha.org> parents: 26033 diff changeset	719 if (r < 0)
8da628be211b reachableroots: reduce nesting level by jumping to next iteration by continue Yuya Nishihara <yuya@tcha.org> parents: 26033 diff changeset	720 goto bail;
8da628be211b reachableroots: reduce nesting level by jumping to next iteration by continue Yuya Nishihara <yuya@tcha.org> parents: 26033 diff changeset	721 for (i = 0; i < 2; i++) {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	722 if (!(revstates[parents[i] + 1] & RS_SEEN) &&
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	723 parents[i] >= minroot) {
26041 8da628be211b reachableroots: reduce nesting level by jumping to next iteration by continue Yuya Nishihara <yuya@tcha.org> parents: 26033 diff changeset	724 tovisit[lentovisit++] = parents[i];
26044 b3ad349d0e50 reachableroots: extend "revstates" to array of bit flags Yuya Nishihara <yuya@tcha.org> parents: 26043 diff changeset	725 revstates[parents[i] + 1] \|= RS_SEEN;
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	726 }
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	727 }
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	728 }
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	729
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	730 /* Find all the nodes in between the roots we found and the heads
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	731 * and add them to the reachable set */
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	732 if (includepath == 1) {
26080 83c9edcac05c reachableroots: silence warning of implicit integer narrowing issued by clang Yuya Nishihara <yuya@tcha.org> parents: 26079 diff changeset	733 long minidx = minroot;
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	734 if (minidx < 0)
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	735 minidx = 0;
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	736 for (i = minidx; i < len; i++) {
26044 b3ad349d0e50 reachableroots: extend "revstates" to array of bit flags Yuya Nishihara <yuya@tcha.org> parents: 26043 diff changeset	737 if (!(revstates[i + 1] & RS_SEEN))
26041 8da628be211b reachableroots: reduce nesting level by jumping to next iteration by continue Yuya Nishihara <yuya@tcha.org> parents: 26033 diff changeset	738 continue;
8da628be211b reachableroots: reduce nesting level by jumping to next iteration by continue Yuya Nishihara <yuya@tcha.org> parents: 26033 diff changeset	739 r = index_get_parents(self, i, parents, (int)len - 1);
8da628be211b reachableroots: reduce nesting level by jumping to next iteration by continue Yuya Nishihara <yuya@tcha.org> parents: 26033 diff changeset	740 /* Corrupted index file, error is set from
8da628be211b reachableroots: reduce nesting level by jumping to next iteration by continue Yuya Nishihara <yuya@tcha.org> parents: 26033 diff changeset	741 * index_get_parents */
8da628be211b reachableroots: reduce nesting level by jumping to next iteration by continue Yuya Nishihara <yuya@tcha.org> parents: 26033 diff changeset	742 if (r < 0)
8da628be211b reachableroots: reduce nesting level by jumping to next iteration by continue Yuya Nishihara <yuya@tcha.org> parents: 26033 diff changeset	743 goto bail;
26059 8779ce81ea80 reachableroots: unroll loop that checks if one of parents is reachable Yuya Nishihara <yuya@tcha.org> parents: 26058 diff changeset	744 if (((revstates[parents[0] + 1] \|
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	745 revstates[parents[1] + 1]) &
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	746 RS_REACHABLE) &&
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	747 !(revstates[i + 1] & RS_REACHABLE)) {
26059 8779ce81ea80 reachableroots: unroll loop that checks if one of parents is reachable Yuya Nishihara <yuya@tcha.org> parents: 26058 diff changeset	748 revstates[i + 1] \|= RS_REACHABLE;
39074 acd23830bcd6 cext: fix most truncation warnings in revlog on Windows Matt Harbison <matt_harbison@yahoo.com> parents: 39073 diff changeset	749 val = PyInt_FromSsize_t(i);
26059 8779ce81ea80 reachableroots: unroll loop that checks if one of parents is reachable Yuya Nishihara <yuya@tcha.org> parents: 26058 diff changeset	750 if (val == NULL)
8779ce81ea80 reachableroots: unroll loop that checks if one of parents is reachable Yuya Nishihara <yuya@tcha.org> parents: 26058 diff changeset	751 goto bail;
8779ce81ea80 reachableroots: unroll loop that checks if one of parents is reachable Yuya Nishihara <yuya@tcha.org> parents: 26058 diff changeset	752 r = PyList_Append(reachable, val);
8779ce81ea80 reachableroots: unroll loop that checks if one of parents is reachable Yuya Nishihara <yuya@tcha.org> parents: 26058 diff changeset	753 Py_DECREF(val);
8779ce81ea80 reachableroots: unroll loop that checks if one of parents is reachable Yuya Nishihara <yuya@tcha.org> parents: 26058 diff changeset	754 if (r < 0)
8779ce81ea80 reachableroots: unroll loop that checks if one of parents is reachable Yuya Nishihara <yuya@tcha.org> parents: 26058 diff changeset	755 goto bail;
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	756 }
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	757 }
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	758 }
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	759
26043 f2f0a3ab6e41 reachableroots: rename "seen" array to "revstates" for future extension Yuya Nishihara <yuya@tcha.org> parents: 26042 diff changeset	760 free(revstates);
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	761 free(tovisit);
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	762 return reachable;
26016 c8d41c9c23c7 reachableroots: unify bail cases to raise exception correctly Yuya Nishihara <yuya@tcha.org> parents: 26015 diff changeset	763 bail:
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	764 Py_XDECREF(reachable);
26043 f2f0a3ab6e41 reachableroots: rename "seen" array to "revstates" for future extension Yuya Nishihara <yuya@tcha.org> parents: 26042 diff changeset	765 free(revstates);
26016 c8d41c9c23c7 reachableroots: unify bail cases to raise exception correctly Yuya Nishihara <yuya@tcha.org> parents: 26015 diff changeset	766 free(tovisit);
26010 2c03e521a0c5 reachableroots: return NULL if we're throwing an exception Augie Fackler <augie@google.com> parents: 26009 diff changeset	767 return NULL;
26004 ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	768 }
ff89383a97db reachableroots: add a C implementation Laurent Charignon <lcharignon@fb.com> parents: 25911 diff changeset	769
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	770 static PyObject compute_phases_map_sets(indexObject self, PyObject *args)
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	771 {
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	772 PyObject *roots = Py_None;
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	773 PyObject *ret = NULL;
35309 d13526333835 phases: drop the list with phase of each rev, always comput phase sets Joerg Sonnenberger <joerg@bec.de> parents: 34861 diff changeset	774 PyObject *phasessize = NULL;
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	775 PyObject *phaseroots = NULL;
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	776 PyObject *phaseset = NULL;
22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	777 PyObject *phasessetlist = NULL;
25911 f4386cb3252e parsers: fix memory leak in compute_phases_map_sets Laurent Charignon <lcharignon@fb.com> parents: 25860 diff changeset	778 PyObject *rev = NULL;
38851 781b2720d2ac index: don't include nullid in len() Martin von Zweigbergk <martinvonz@google.com> parents: 38850 diff changeset	779 Py_ssize_t len = index_length(self);
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	780 Py_ssize_t numphase = 0;
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	781 Py_ssize_t minrevallphases = 0;
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	782 Py_ssize_t minrevphase = 0;
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	783 Py_ssize_t i = 0;
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	784 char *phases = NULL;
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	785 long phase;
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	786
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	787 if (!PyArg_ParseTuple(args, "O", &roots))
27364 ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	788 goto done;
36623 a472a897c340 cext: fix computephasesmapsets() not to return without setting an exception Yuya Nishihara <yuya@tcha.org> parents: 36621 diff changeset	789 if (roots == NULL \|\| !PyList_Check(roots)) {
a472a897c340 cext: fix computephasesmapsets() not to return without setting an exception Yuya Nishihara <yuya@tcha.org> parents: 36621 diff changeset	790 PyErr_SetString(PyExc_TypeError, "roots must be a list");
27364 ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	791 goto done;
36623 a472a897c340 cext: fix computephasesmapsets() not to return without setting an exception Yuya Nishihara <yuya@tcha.org> parents: 36621 diff changeset	792 }
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	793
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	794 phases = calloc(
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	795 len, 1); /* phase per rev: {0: public, 1: draft, 2: secret} */
27364 ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	796 if (phases == NULL) {
ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	797 PyErr_NoMemory();
ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	798 goto done;
ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	799 }
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	800 /* Put the phase information of all the roots in phases */
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	801 numphase = PyList_GET_SIZE(roots) + 1;
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	802 minrevallphases = len + 1;
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	803 phasessetlist = PyList_New(numphase);
22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	804 if (phasessetlist == NULL)
27364 ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	805 goto done;
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	806
22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	807 PyList_SET_ITEM(phasessetlist, 0, Py_None);
22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	808 Py_INCREF(Py_None);
22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	809
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	810 for (i = 0; i < numphase - 1; i++) {
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	811 phaseroots = PyList_GET_ITEM(roots, i);
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	812 phaseset = PySet_New(NULL);
22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	813 if (phaseset == NULL)
27364 ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	814 goto release;
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	815 PyList_SET_ITEM(phasessetlist, i + 1, phaseset);
36623 a472a897c340 cext: fix computephasesmapsets() not to return without setting an exception Yuya Nishihara <yuya@tcha.org> parents: 36621 diff changeset	816 if (!PyList_Check(phaseroots)) {
a472a897c340 cext: fix computephasesmapsets() not to return without setting an exception Yuya Nishihara <yuya@tcha.org> parents: 36621 diff changeset	817 PyErr_SetString(PyExc_TypeError,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	818 "roots item must be a list");
27364 ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	819 goto release;
36623 a472a897c340 cext: fix computephasesmapsets() not to return without setting an exception Yuya Nishihara <yuya@tcha.org> parents: 36621 diff changeset	820 }
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	821 minrevphase =
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	822 add_roots_get_min(self, phaseroots, i + 1, phases);
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	823 if (minrevphase == -2) /* Error from add_roots_get_min */
27364 ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	824 goto release;
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	825 minrevallphases = MIN(minrevallphases, minrevphase);
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	826 }
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	827 /* Propagate the phase information from the roots to the revs */
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	828 if (minrevallphases != -1) {
25312 ee02728dd5f9 parsers: simplify the code computing the phases Laurent Charignon <lcharignon@fb.com> parents: 25311 diff changeset	829 int parents[2];
ee02728dd5f9 parsers: simplify the code computing the phases Laurent Charignon <lcharignon@fb.com> parents: 25311 diff changeset	830 for (i = minrevallphases; i < len; i++) {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	831 if (index_get_parents(self, i, parents, (int)len - 1) <
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	832 0)
27364 ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	833 goto release;
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	834 set_phase_from_parents(phases, parents[0], parents[1],
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	835 i);
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	836 }
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	837 }
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	838 /* Transform phase list to a python list */
39074 acd23830bcd6 cext: fix most truncation warnings in revlog on Windows Matt Harbison <matt_harbison@yahoo.com> parents: 39073 diff changeset	839 phasessize = PyInt_FromSsize_t(len);
35309 d13526333835 phases: drop the list with phase of each rev, always comput phase sets Joerg Sonnenberger <joerg@bec.de> parents: 34861 diff changeset	840 if (phasessize == NULL)
27364 ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	841 goto release;
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	842 for (i = 0; i < len; i++) {
22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	843 phase = phases[i];
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	844 /* We only store the sets of phase for non public phase, the
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	845 * public phase is computed as a difference */
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	846 if (phase != 0) {
22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	847 phaseset = PyList_GET_ITEM(phasessetlist, phase);
39074 acd23830bcd6 cext: fix most truncation warnings in revlog on Windows Matt Harbison <matt_harbison@yahoo.com> parents: 39073 diff changeset	848 rev = PyInt_FromSsize_t(i);
27365 ec04370bdfaf parsers: check results of PyInt_FromLong (issue4771) Bryan O'Sullivan <bos@serpentine.com> parents: 27364 diff changeset	849 if (rev == NULL)
ec04370bdfaf parsers: check results of PyInt_FromLong (issue4771) Bryan O'Sullivan <bos@serpentine.com> parents: 27364 diff changeset	850 goto release;
25911 f4386cb3252e parsers: fix memory leak in compute_phases_map_sets Laurent Charignon <lcharignon@fb.com> parents: 25860 diff changeset	851 PySet_Add(phaseset, rev);
f4386cb3252e parsers: fix memory leak in compute_phases_map_sets Laurent Charignon <lcharignon@fb.com> parents: 25860 diff changeset	852 Py_XDECREF(rev);
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	853 }
22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	854 }
35309 d13526333835 phases: drop the list with phase of each rev, always comput phase sets Joerg Sonnenberger <joerg@bec.de> parents: 34861 diff changeset	855 ret = PyTuple_Pack(2, phasessize, phasessetlist);
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	856
27364 ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	857 release:
35309 d13526333835 phases: drop the list with phase of each rev, always comput phase sets Joerg Sonnenberger <joerg@bec.de> parents: 34861 diff changeset	858 Py_XDECREF(phasessize);
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	859 Py_XDECREF(phasessetlist);
27364 ad1cc1435b13 parsers: simplify error logic in compute_phases_map_sets Bryan O'Sullivan <bos@serpentine.com> parents: 27341 diff changeset	860 done:
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	861 free(phases);
25190 22438cfd11b5 phases: add set per phase in C phase computation Laurent Charignon <lcharignon@fb.com> parents: 24879 diff changeset	862 return ret;
24443 539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	863 }
539b3c7eea44 phase: compute phases in C Laurent Charignon <lcharignon@fb.com> parents: 24214 diff changeset	864
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	865 static PyObject index_headrevs(indexObject self, PyObject *args)
16786 2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	866 {
25297 3966e39fea98 changelog: fix bug in heads computation Laurent Charignon <lcharignon@fb.com> parents: 25296 diff changeset	867 Py_ssize_t i, j, len;
16786 2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	868 char *nothead = NULL;
22540 9a860ac8c216 parsers: fix uninitialize variable warning David Soria Parra <davidsp@fb.com> parents: 22484 diff changeset	869 PyObject *heads = NULL;
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	870 PyObject *filter = NULL;
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	871 PyObject *filteredrevs = Py_None;
16786 2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	872
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	873 if (!PyArg_ParseTuple(args, "\|O", &filteredrevs)) {
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	874 return NULL;
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	875 }
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	876
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	877 if (self->headrevs && filteredrevs == self->filteredrevs)
16787 bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	878 return list_copy(self->headrevs);
bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	879
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	880 Py_DECREF(self->filteredrevs);
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	881 self->filteredrevs = filteredrevs;
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	882 Py_INCREF(filteredrevs);
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	883
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	884 if (filteredrevs != Py_None) {
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	885 filter = PyObject_GetAttrString(filteredrevs, "__contains__");
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	886 if (!filter) {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	887 PyErr_SetString(
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	888 PyExc_TypeError,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	889 "filteredrevs has no attribute __contains__");
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	890 goto bail;
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	891 }
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	892 }
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	893
38851 781b2720d2ac index: don't include nullid in len() Martin von Zweigbergk <martinvonz@google.com> parents: 38850 diff changeset	894 len = index_length(self);
16786 2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	895 heads = PyList_New(0);
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	896 if (heads == NULL)
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	897 goto bail;
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	898 if (len == 0) {
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	899 PyObject *nullid = PyInt_FromLong(-1);
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	900 if (nullid == NULL \|\| PyList_Append(heads, nullid) == -1) {
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	901 Py_XDECREF(nullid);
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	902 goto bail;
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	903 }
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	904 goto done;
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	905 }
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	906
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	907 nothead = calloc(len, 1);
27366 7e8a883da171 parsers: add a missed PyErr_NoMemory Bryan O'Sullivan <bos@serpentine.com> parents: 27365 diff changeset	908 if (nothead == NULL) {
7e8a883da171 parsers: add a missed PyErr_NoMemory Bryan O'Sullivan <bos@serpentine.com> parents: 27365 diff changeset	909 PyErr_NoMemory();
16786 2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	910 goto bail;
27366 7e8a883da171 parsers: add a missed PyErr_NoMemory Bryan O'Sullivan <bos@serpentine.com> parents: 27365 diff changeset	911 }
16786 2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	912
28386 1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	913 for (i = len - 1; i >= 0; i--) {
25297 3966e39fea98 changelog: fix bug in heads computation Laurent Charignon <lcharignon@fb.com> parents: 25296 diff changeset	914 int isfiltered;
3966e39fea98 changelog: fix bug in heads computation Laurent Charignon <lcharignon@fb.com> parents: 25296 diff changeset	915 int parents[2];
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	916
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	917 /* If nothead[i] == 1, it means we've seen an unfiltered child
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	918 * of this node already, and therefore this node is not
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	919 * filtered. So we can skip the expensive check_filter step.
28386 1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	920 */
1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	921 if (nothead[i] != 1) {
1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	922 isfiltered = check_filter(filter, i);
1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	923 if (isfiltered == -1) {
1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	924 PyErr_SetString(PyExc_TypeError,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	925 "unable to check filter");
28386 1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	926 goto bail;
1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	927 }
1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	928
1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	929 if (isfiltered) {
1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	930 nothead[i] = 1;
1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	931 continue;
1c658391b22f parsers: optimize filtered headrevs logic Durham Goode <durham@fb.com> parents: 27638 diff changeset	932 }
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	933 }
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	934
25860 895f04955a49 parsers: silence warning of implicit integer conversion issued by clang Yuya Nishihara <yuya@tcha.org> parents: 25810 diff changeset	935 if (index_get_parents(self, i, parents, (int)len - 1) < 0)
25810 82d6a35cf432 parsers: fix buffer overflow by invalid parent revision read from revlog Yuya Nishihara <yuya@tcha.org> parents: 25584 diff changeset	936 goto bail;
25297 3966e39fea98 changelog: fix bug in heads computation Laurent Charignon <lcharignon@fb.com> parents: 25296 diff changeset	937 for (j = 0; j < 2; j++) {
3966e39fea98 changelog: fix bug in heads computation Laurent Charignon <lcharignon@fb.com> parents: 25296 diff changeset	938 if (parents[j] >= 0)
3966e39fea98 changelog: fix bug in heads computation Laurent Charignon <lcharignon@fb.com> parents: 25296 diff changeset	939 nothead[parents[j]] = 1;
16786 2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	940 }
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	941 }
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	942
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	943 for (i = 0; i < len; i++) {
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	944 PyObject *head;
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	945
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	946 if (nothead[i])
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	947 continue;
22400 888bc106de83 parsers: fix typing issue when constructing Python integer object Henrik Stuart <hg@hstuart.dk> parents: 22399 diff changeset	948 head = PyInt_FromSsize_t(i);
16786 2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	949 if (head == NULL \|\| PyList_Append(heads, head) == -1) {
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	950 Py_XDECREF(head);
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	951 goto bail;
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	952 }
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	953 }
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	954
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	955 done:
16787 bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	956 self->headrevs = heads;
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	957 Py_XDECREF(filter);
16786 2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	958 free(nothead);
16787 bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	959 return list_copy(self->headrevs);
16786 2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	960 bail:
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	961 Py_XDECREF(filter);
16786 2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	962 Py_XDECREF(heads);
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	963 free(nothead);
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	964 return NULL;
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	965 }
2631cd5dd244 revlog: switch to a C version of headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16784 diff changeset	966
33174 f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	967 /**
f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	968 * Obtain the base revision index entry.
f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	969 *
f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	970 * Callers must ensure that rev >= 0 or illegal memory access may occur.
f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	971 */
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	972 static inline int index_baserev(indexObject *self, int rev)
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	973 {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	974 const char *data;
41018 f4113489e4d4 revlog: catch revlog corruption in index_baserev Boris Feld <boris.feld@octobus.net> parents: 40813 diff changeset	975 int result;
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	976
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	977 if (rev >= self->length) {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	978 PyObject *tuple =
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	979 PyList_GET_ITEM(self->added, rev - self->length);
40598 fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	980 long ret;
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	981 if (!pylong_to_long(PyTuple_GET_ITEM(tuple, 3), &ret)) {
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	982 return -2;
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	983 }
41078 46e0563c67db merge with stable Yuya Nishihara <yuya@tcha.org> parents: 41052 41018 diff changeset	984 result = (int)ret;
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	985 } else {
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	986 data = index_deref(self, rev);
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	987 if (data == NULL) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	988 return -2;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	989 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	990
41018 f4113489e4d4 revlog: catch revlog corruption in index_baserev Boris Feld <boris.feld@octobus.net> parents: 40813 diff changeset	991 result = getbe32(data + 16);
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	992 }
41018 f4113489e4d4 revlog: catch revlog corruption in index_baserev Boris Feld <boris.feld@octobus.net> parents: 40813 diff changeset	993 if (result > rev) {
f4113489e4d4 revlog: catch revlog corruption in index_baserev Boris Feld <boris.feld@octobus.net> parents: 40813 diff changeset	994 PyErr_Format(
f4113489e4d4 revlog: catch revlog corruption in index_baserev Boris Feld <boris.feld@octobus.net> parents: 40813 diff changeset	995 PyExc_ValueError,
f4113489e4d4 revlog: catch revlog corruption in index_baserev Boris Feld <boris.feld@octobus.net> parents: 40813 diff changeset	996 "corrupted revlog, revision base above revision: %d, %d",
f4113489e4d4 revlog: catch revlog corruption in index_baserev Boris Feld <boris.feld@octobus.net> parents: 40813 diff changeset	997 rev, result);
f4113489e4d4 revlog: catch revlog corruption in index_baserev Boris Feld <boris.feld@octobus.net> parents: 40813 diff changeset	998 return -2;
f4113489e4d4 revlog: catch revlog corruption in index_baserev Boris Feld <boris.feld@octobus.net> parents: 40813 diff changeset	999 }
41019 7542466b94e2 revlog: cache delta base value under -1 Boris Feld <boris.feld@octobus.net> parents: 41018 diff changeset	1000 if (result < -1) {
7542466b94e2 revlog: cache delta base value under -1 Boris Feld <boris.feld@octobus.net> parents: 41018 diff changeset	1001 PyErr_Format(
7542466b94e2 revlog: cache delta base value under -1 Boris Feld <boris.feld@octobus.net> parents: 41018 diff changeset	1002 PyExc_ValueError,
41283 4948b327d3b9 cext: clang-format new code coming from stable branch Yuya Nishihara <yuya@tcha.org> parents: 41129 diff changeset	1003 "corrupted revlog, revision base out of range: %d, %d", rev,
4948b327d3b9 cext: clang-format new code coming from stable branch Yuya Nishihara <yuya@tcha.org> parents: 41129 diff changeset	1004 result);
41019 7542466b94e2 revlog: cache delta base value under -1 Boris Feld <boris.feld@octobus.net> parents: 41018 diff changeset	1005 return -2;
7542466b94e2 revlog: cache delta base value under -1 Boris Feld <boris.feld@octobus.net> parents: 41018 diff changeset	1006 }
41018 f4113489e4d4 revlog: catch revlog corruption in index_baserev Boris Feld <boris.feld@octobus.net> parents: 40813 diff changeset	1007 return result;
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1008 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1009
41085 a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1010 /**
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1011 * Find if a revision is a snapshot or not
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1012 *
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1013 * Only relevant for sparse-revlog case.
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1014 * Callers must ensure that rev is in a valid range.
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1015 */
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1016 static int index_issnapshotrev(indexObject *self, Py_ssize_t rev)
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1017 {
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1018 int ps[2];
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1019 Py_ssize_t base;
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1020 while (rev >= 0) {
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1021 base = (Py_ssize_t)index_baserev(self, rev);
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1022 if (base == rev) {
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1023 base = -1;
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1024 }
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1025 if (base == -2) {
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1026 assert(PyErr_Occurred());
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1027 return -1;
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1028 }
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1029 if (base == -1) {
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1030 return 1;
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1031 }
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1032 if (index_get_parents(self, rev, ps, (int)rev) < 0) {
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1033 assert(PyErr_Occurred());
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1034 return -1;
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1035 };
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1036 if (base == ps[0] \|\| base == ps[1]) {
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1037 return 0;
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1038 }
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1039 rev = base;
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1040 }
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1041 return rev == -1;
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1042 }
a6556b09bf83 revlog: add a native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41078 diff changeset	1043
41086 a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1044 static PyObject index_issnapshot(indexObject self, PyObject *value)
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1045 {
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1046 long rev;
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1047 int issnap;
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1048 Py_ssize_t length = index_length(self);
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1049
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1050 if (!pylong_to_long(value, &rev)) {
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1051 return NULL;
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1052 }
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1053 if (rev < -1 \|\| rev >= length) {
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1054 PyErr_Format(PyExc_ValueError, "revlog index out of range: %ld",
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1055 rev);
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1056 return NULL;
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1057 };
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1058 issnap = index_issnapshotrev(self, (Py_ssize_t)rev);
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1059 if (issnap < 0) {
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1060 return NULL;
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1061 };
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1062 return PyBool_FromLong((long)issnap);
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1063 }
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	1064
41108 38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1065 static PyObject index_findsnapshots(indexObject self, PyObject *args)
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1066 {
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1067 Py_ssize_t start_rev;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1068 PyObject *cache;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1069 Py_ssize_t base;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1070 Py_ssize_t rev;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1071 PyObject *key = NULL;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1072 PyObject *value = NULL;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1073 const Py_ssize_t length = index_length(self);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1074 if (!PyArg_ParseTuple(args, "O!n", &PyDict_Type, &cache, &start_rev)) {
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1075 return NULL;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1076 }
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1077 for (rev = start_rev; rev < length; rev++) {
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1078 int issnap;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1079 PyObject *allvalues = NULL;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1080 issnap = index_issnapshotrev(self, rev);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1081 if (issnap < 0) {
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1082 goto bail;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1083 }
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1084 if (issnap == 0) {
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1085 continue;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1086 }
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1087 base = (Py_ssize_t)index_baserev(self, rev);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1088 if (base == rev) {
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1089 base = -1;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1090 }
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1091 if (base == -2) {
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1092 assert(PyErr_Occurred());
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1093 goto bail;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1094 }
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1095 key = PyInt_FromSsize_t(base);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1096 allvalues = PyDict_GetItem(cache, key);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1097 if (allvalues == NULL && PyErr_Occurred()) {
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1098 goto bail;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1099 }
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1100 if (allvalues == NULL) {
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1101 int r;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1102 allvalues = PyList_New(0);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1103 if (!allvalues) {
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1104 goto bail;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1105 }
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1106 r = PyDict_SetItem(cache, key, allvalues);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1107 Py_DECREF(allvalues);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1108 if (r < 0) {
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1109 goto bail;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1110 }
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1111 }
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1112 value = PyInt_FromSsize_t(rev);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1113 if (PyList_Append(allvalues, value)) {
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1114 goto bail;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1115 }
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1116 Py_CLEAR(key);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1117 Py_CLEAR(value);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1118 }
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1119 Py_RETURN_NONE;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1120 bail:
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1121 Py_XDECREF(key);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1122 Py_XDECREF(value);
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1123 return NULL;
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1124 }
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	1125
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1126 static PyObject index_deltachain(indexObject self, PyObject *args)
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1127 {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1128 int rev, generaldelta;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1129 PyObject *stoparg;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1130 int stoprev, iterrev, baserev = -1;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1131 int stopped;
33174 f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	1132 PyObject chain = NULL, result = NULL;
38868 0db50770f388 index: don't add 1 to length variables Martin von Zweigbergk <martinvonz@google.com> parents: 38867 diff changeset	1133 const Py_ssize_t length = index_length(self);
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1134
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1135 if (!PyArg_ParseTuple(args, "iOi", &rev, &stoparg, &generaldelta)) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1136 return NULL;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1137 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1138
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1139 if (PyInt_Check(stoparg)) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1140 stoprev = (int)PyInt_AsLong(stoparg);
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1141 if (stoprev == -1 && PyErr_Occurred()) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1142 return NULL;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1143 }
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1144 } else if (stoparg == Py_None) {
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1145 stoprev = -2;
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1146 } else {
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1147 PyErr_SetString(PyExc_ValueError,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1148 "stoprev must be integer or None");
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1149 return NULL;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1150 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1151
38868 0db50770f388 index: don't add 1 to length variables Martin von Zweigbergk <martinvonz@google.com> parents: 38867 diff changeset	1152 if (rev < 0 \|\| rev >= length) {
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1153 PyErr_SetString(PyExc_ValueError, "revlog index out of range");
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1154 return NULL;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1155 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1156
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1157 chain = PyList_New(0);
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1158 if (chain == NULL) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1159 return NULL;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1160 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1161
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1162 baserev = index_baserev(self, rev);
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1163
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1164 /* This should never happen. */
33174 f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	1165 if (baserev <= -2) {
f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	1166 /* Error should be set by index_deref() */
f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	1167 assert(PyErr_Occurred());
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1168 goto bail;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1169 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1170
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1171 iterrev = rev;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1172
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1173 while (iterrev != baserev && iterrev != stoprev) {
33174 f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	1174 PyObject *value = PyInt_FromLong(iterrev);
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1175 if (value == NULL) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1176 goto bail;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1177 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1178 if (PyList_Append(chain, value)) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1179 Py_DECREF(value);
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1180 goto bail;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1181 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1182 Py_DECREF(value);
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1183
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1184 if (generaldelta) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1185 iterrev = baserev;
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1186 } else {
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1187 iterrev--;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1188 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1189
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1190 if (iterrev < 0) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1191 break;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1192 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1193
38868 0db50770f388 index: don't add 1 to length variables Martin von Zweigbergk <martinvonz@google.com> parents: 38867 diff changeset	1194 if (iterrev >= length) {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1195 PyErr_SetString(PyExc_IndexError,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1196 "revision outside index");
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1197 return NULL;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1198 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1199
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1200 baserev = index_baserev(self, iterrev);
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1201
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1202 /* This should never happen. */
33174 f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	1203 if (baserev <= -2) {
f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	1204 /* Error should be set by index_deref() */
f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	1205 assert(PyErr_Occurred());
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1206 goto bail;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1207 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1208 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1209
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1210 if (iterrev == stoprev) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1211 stopped = 1;
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1212 } else {
33174 f4f52bb362e6 revlog: address review feedback for deltachain C implementation Gregory Szorc <gregory.szorc@gmail.com> parents: 33171 diff changeset	1213 PyObject *value = PyInt_FromLong(iterrev);
33171 6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1214 if (value == NULL) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1215 goto bail;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1216 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1217 if (PyList_Append(chain, value)) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1218 Py_DECREF(value);
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1219 goto bail;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1220 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1221 Py_DECREF(value);
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1222
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1223 stopped = 0;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1224 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1225
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1226 if (PyList_Reverse(chain)) {
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1227 goto bail;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1228 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1229
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1230 result = Py_BuildValue("OO", chain, stopped ? Py_True : Py_False);
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1231 Py_DECREF(chain);
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1232 return result;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1233
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1234 bail:
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1235 Py_DECREF(chain);
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1236 return NULL;
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1237 }
6d678ab1b10d revlog: C implementation of delta chain resolution Gregory Szorc <gregory.szorc@gmail.com> parents: 32384 diff changeset	1238
40705 4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1239 static inline int64_t
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1240 index_segment_span(indexObject *self, Py_ssize_t start_rev, Py_ssize_t end_rev)
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1241 {
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1242 int64_t start_offset;
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1243 int64_t end_offset;
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1244 int end_size;
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1245 start_offset = index_get_start(self, start_rev);
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1246 if (start_offset < 0) {
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1247 return -1;
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1248 }
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1249 end_offset = index_get_start(self, end_rev);
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1250 if (end_offset < 0) {
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1251 return -1;
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1252 }
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1253 end_size = index_get_length(self, end_rev);
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1254 if (end_size < 0) {
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1255 return -1;
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1256 }
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1257 if (end_offset < start_offset) {
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1258 PyErr_Format(PyExc_ValueError,
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1259 "corrupted revlog index: inconsistent offset "
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1260 "between revisions (%zd) and (%zd)",
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1261 start_rev, end_rev);
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1262 return -1;
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1263 }
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1264 return (end_offset - start_offset) + (int64_t)end_size;
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1265 }
4ec6a24029d2 sparse-revlog: add a `index_segment_span` function in C Boris Feld <boris.feld@octobus.net> parents: 40704 diff changeset	1266
40742 8edca70dc951 revlog: update the documentation for `trim_endidx` Boris Feld <boris.feld@octobus.net> parents: 40741 diff changeset	1267 /* returns endidx so that revs[startidx:endidx] has no empty trailing revs */
40706 0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1268 static Py_ssize_t trim_endidx(indexObject self, const Py_ssize_t revs,
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1269 Py_ssize_t startidx, Py_ssize_t endidx)
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1270 {
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1271 int length;
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1272 while (endidx > 1 && endidx > startidx) {
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1273 length = index_get_length(self, revs[endidx - 1]);
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1274 if (length < 0) {
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1275 return -1;
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1276 }
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1277 if (length != 0) {
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1278 break;
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1279 }
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1280 endidx -= 1;
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1281 }
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1282 return endidx;
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1283 }
0650be877a37 sparse-revlog: add a `trim_endidx` function in C Boris Feld <boris.feld@octobus.net> parents: 40705 diff changeset	1284
40707 cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1285 struct Gap {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1286 int64_t size;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1287 Py_ssize_t idx;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1288 };
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1289
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1290 static int gap_compare(const void left, const void right)
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1291 {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1292 const struct Gap l_left = ((const struct Gap )left);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1293 const struct Gap l_right = ((const struct Gap )right);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1294 if (l_left->size < l_right->size) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1295 return -1;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1296 } else if (l_left->size > l_right->size) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1297 return 1;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1298 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1299 return 0;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1300 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1301 static int Py_ssize_t_compare(const void left, const void right)
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1302 {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1303 const Py_ssize_t l_left = (const Py_ssize_t )left;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1304 const Py_ssize_t l_right = (const Py_ssize_t )right;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1305 if (l_left < l_right) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1306 return -1;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1307 } else if (l_left > l_right) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1308 return 1;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1309 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1310 return 0;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1311 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1312
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1313 static PyObject index_slicechunktodensity(indexObject self, PyObject *args)
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1314 {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1315 /* method arguments */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1316 PyObject list_revs = NULL; / revisions in the chain */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1317 double targetdensity = 0; /* min density to achieve */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1318 Py_ssize_t mingapsize = 0; /* threshold to ignore gaps */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1319
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1320 /* other core variables */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1321 Py_ssize_t idxlen = index_length(self);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1322 Py_ssize_t i; /* used for various iteration */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1323 PyObject result = NULL; / the final return of the function */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1324
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1325 /* generic information about the delta chain being slice */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1326 Py_ssize_t num_revs = 0; /* size of the full delta chain */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1327 Py_ssize_t revs = NULL; / native array of revision in the chain */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1328 int64_t chainpayload = 0; /* sum of all delta in the chain */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1329 int64_t deltachainspan = 0; /* distance from first byte to last byte */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1330
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1331 /* variable used for slicing the delta chain */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1332 int64_t readdata = 0; /* amount of data currently planned to be read */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1333 double density = 0; /* ration of payload data compared to read ones */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1334 int64_t previous_end;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1335 struct Gap gaps = NULL; / array of notable gap in the chain */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1336 Py_ssize_t num_gaps =
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1337 0; /* total number of notable gap recorded so far */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1338 Py_ssize_t selected_indices = NULL; / indices of gap skipped over */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1339 Py_ssize_t num_selected = 0; /* number of gaps skipped */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1340 PyObject chunk = NULL; / individual slice */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1341 PyObject allchunks = NULL; / all slices */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1342 Py_ssize_t previdx;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1343
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1344 /* parsing argument */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1345 if (!PyArg_ParseTuple(args, "O!dn", &PyList_Type, &list_revs,
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1346 &targetdensity, &mingapsize)) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1347 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1348 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1349
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1350 /* If the delta chain contains a single element, we do not need slicing
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1351 */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1352 num_revs = PyList_GET_SIZE(list_revs);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1353 if (num_revs <= 1) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1354 result = PyTuple_Pack(1, list_revs);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1355 goto done;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1356 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1357
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1358 /* Turn the python list into a native integer array (for efficiency) */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1359 revs = (Py_ssize_t *)calloc(num_revs, sizeof(Py_ssize_t));
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1360 if (revs == NULL) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1361 PyErr_NoMemory();
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1362 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1363 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1364 for (i = 0; i < num_revs; i++) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1365 Py_ssize_t revnum = PyInt_AsLong(PyList_GET_ITEM(list_revs, i));
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1366 if (revnum == -1 && PyErr_Occurred()) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1367 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1368 }
40963 2e305e54eae3 sparse-revlog: protect C code against delta chain including nullrev Boris Feld <boris.feld@octobus.net> parents: 40962 diff changeset	1369 if (revnum < nullrev \|\| revnum >= idxlen) {
40756 c85964d715fd sparse: raise a move verbose index error from the C code Boris Feld <boris.feld@octobus.net> parents: 40742 diff changeset	1370 PyErr_Format(PyExc_IndexError,
c85964d715fd sparse: raise a move verbose index error from the C code Boris Feld <boris.feld@octobus.net> parents: 40742 diff changeset	1371 "index out of range: %zd", revnum);
40707 cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1372 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1373 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1374 revs[i] = revnum;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1375 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1376
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1377 /* Compute and check various property of the unsliced delta chain */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1378 deltachainspan = index_segment_span(self, revs[0], revs[num_revs - 1]);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1379 if (deltachainspan < 0) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1380 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1381 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1382
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1383 if (deltachainspan <= mingapsize) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1384 result = PyTuple_Pack(1, list_revs);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1385 goto done;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1386 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1387 chainpayload = 0;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1388 for (i = 0; i < num_revs; i++) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1389 int tmp = index_get_length(self, revs[i]);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1390 if (tmp < 0) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1391 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1392 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1393 chainpayload += tmp;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1394 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1395
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1396 readdata = deltachainspan;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1397 density = 1.0;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1398
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1399 if (0 < deltachainspan) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1400 density = (double)chainpayload / (double)deltachainspan;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1401 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1402
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1403 if (density >= targetdensity) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1404 result = PyTuple_Pack(1, list_revs);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1405 goto done;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1406 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1407
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1408 /* if chain is too sparse, look for relevant gaps */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1409 gaps = (struct Gap *)calloc(num_revs, sizeof(struct Gap));
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1410 if (gaps == NULL) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1411 PyErr_NoMemory();
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1412 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1413 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1414
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1415 previous_end = -1;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1416 for (i = 0; i < num_revs; i++) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1417 int64_t revstart;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1418 int revsize;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1419 revstart = index_get_start(self, revs[i]);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1420 if (revstart < 0) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1421 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1422 };
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1423 revsize = index_get_length(self, revs[i]);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1424 if (revsize < 0) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1425 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1426 };
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1427 if (revsize == 0) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1428 continue;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1429 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1430 if (previous_end >= 0) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1431 int64_t gapsize = revstart - previous_end;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1432 if (gapsize > mingapsize) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1433 gaps[num_gaps].size = gapsize;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1434 gaps[num_gaps].idx = i;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1435 num_gaps += 1;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1436 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1437 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1438 previous_end = revstart + revsize;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1439 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1440 if (num_gaps == 0) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1441 result = PyTuple_Pack(1, list_revs);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1442 goto done;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1443 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1444 qsort(gaps, num_gaps, sizeof(struct Gap), &gap_compare);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1445
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1446 /* Slice the largest gap first, they improve the density the most */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1447 selected_indices =
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1448 (Py_ssize_t )malloc((num_gaps + 1) sizeof(Py_ssize_t));
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1449 if (selected_indices == NULL) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1450 PyErr_NoMemory();
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1451 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1452 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1453
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1454 for (i = num_gaps - 1; i >= 0; i--) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1455 selected_indices[num_selected] = gaps[i].idx;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1456 readdata -= gaps[i].size;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1457 num_selected += 1;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1458 if (readdata <= 0) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1459 density = 1.0;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1460 } else {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1461 density = (double)chainpayload / (double)readdata;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1462 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1463 if (density >= targetdensity) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1464 break;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1465 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1466 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1467 qsort(selected_indices, num_selected, sizeof(Py_ssize_t),
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1468 &Py_ssize_t_compare);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1469
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1470 /* create the resulting slice */
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1471 allchunks = PyList_New(0);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1472 if (allchunks == NULL) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1473 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1474 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1475 previdx = 0;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1476 selected_indices[num_selected] = num_revs;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1477 for (i = 0; i <= num_selected; i++) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1478 Py_ssize_t idx = selected_indices[i];
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1479 Py_ssize_t endidx = trim_endidx(self, revs, previdx, idx);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1480 if (endidx < 0) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1481 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1482 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1483 if (previdx < endidx) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1484 chunk = PyList_GetSlice(list_revs, previdx, endidx);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1485 if (chunk == NULL) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1486 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1487 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1488 if (PyList_Append(allchunks, chunk) == -1) {
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1489 goto bail;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1490 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1491 Py_DECREF(chunk);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1492 chunk = NULL;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1493 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1494 previdx = idx;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1495 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1496 result = allchunks;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1497 goto done;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1498
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1499 bail:
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1500 Py_XDECREF(allchunks);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1501 Py_XDECREF(chunk);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1502 done:
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1503 free(revs);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1504 free(gaps);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1505 free(selected_indices);
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1506 return result;
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1507 }
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	1508
16618 6bae941b58ad parsers: change the type of nt_level Bryan O'Sullivan <bryano@fb.com> parents: 16617 diff changeset	1509 static inline int nt_level(const char *node, Py_ssize_t level)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1510 {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1511 int v = node[level >> 1];
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1512 if (!(level & 1))
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1513 v >>= 4;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1514 return v & 0xf;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1515 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1516
16616 8f79aabd96f6 parsers: allow nt_find to signal an ambiguous match Bryan O'Sullivan <bryano@fb.com> parents: 16615 diff changeset	1517 /*
8f79aabd96f6 parsers: allow nt_find to signal an ambiguous match Bryan O'Sullivan <bryano@fb.com> parents: 16615 diff changeset	1518 * Return values:
8f79aabd96f6 parsers: allow nt_find to signal an ambiguous match Bryan O'Sullivan <bryano@fb.com> parents: 16615 diff changeset	1519 *
8f79aabd96f6 parsers: allow nt_find to signal an ambiguous match Bryan O'Sullivan <bryano@fb.com> parents: 16615 diff changeset	1520 * -4: match is ambiguous (multiple candidates)
8f79aabd96f6 parsers: allow nt_find to signal an ambiguous match Bryan O'Sullivan <bryano@fb.com> parents: 16615 diff changeset	1521 * -2: not found
8f79aabd96f6 parsers: allow nt_find to signal an ambiguous match Bryan O'Sullivan <bryano@fb.com> parents: 16615 diff changeset	1522 * rest: valid rev
8f79aabd96f6 parsers: allow nt_find to signal an ambiguous match Bryan O'Sullivan <bryano@fb.com> parents: 16615 diff changeset	1523 */
38940 b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1524 static int nt_find(nodetree self, const char node, Py_ssize_t nodelen,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1525 int hex)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1526 {
16663 a955e05dd7a0 parsers: allow hex keys Bryan O'Sullivan <bryano@fb.com> parents: 16642 diff changeset	1527 int (getnybble)(const char , Py_ssize_t) = hex ? hexdigit : nt_level;
16641 e6dfbc5df76f parsers: use the correct maximum radix tree depth Bryan O'Sullivan <bryano@fb.com> parents: 16604 diff changeset	1528 int level, maxlevel, off;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1529
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1530 if (nodelen == 20 && node[0] == '\0' && memcmp(node, nullid, 20) == 0)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1531 return -1;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1532
16663 a955e05dd7a0 parsers: allow hex keys Bryan O'Sullivan <bryano@fb.com> parents: 16642 diff changeset	1533 if (hex)
16665 e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1534 maxlevel = nodelen > 40 ? 40 : (int)nodelen;
16663 a955e05dd7a0 parsers: allow hex keys Bryan O'Sullivan <bryano@fb.com> parents: 16642 diff changeset	1535 else
a955e05dd7a0 parsers: allow hex keys Bryan O'Sullivan <bryano@fb.com> parents: 16642 diff changeset	1536 maxlevel = nodelen > 20 ? 40 : ((int)nodelen * 2);
16641 e6dfbc5df76f parsers: use the correct maximum radix tree depth Bryan O'Sullivan <bryano@fb.com> parents: 16604 diff changeset	1537
e6dfbc5df76f parsers: use the correct maximum radix tree depth Bryan O'Sullivan <bryano@fb.com> parents: 16604 diff changeset	1538 for (level = off = 0; level < maxlevel; level++) {
16663 a955e05dd7a0 parsers: allow hex keys Bryan O'Sullivan <bryano@fb.com> parents: 16642 diff changeset	1539 int k = getnybble(node, level);
38940 b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1540 nodetreenode *n = &self->nodes[off];
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1541 int v = n->children[k];
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1542
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1543 if (v < 0) {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1544 const char *n;
16663 a955e05dd7a0 parsers: allow hex keys Bryan O'Sullivan <bryano@fb.com> parents: 16642 diff changeset	1545 Py_ssize_t i;
a955e05dd7a0 parsers: allow hex keys Bryan O'Sullivan <bryano@fb.com> parents: 16642 diff changeset	1546
38846 f738c502e43b index: store nullrev as -1 in nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38845 diff changeset	1547 v = -(v + 2);
38940 b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1548 n = index_node(self->index, v);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1549 if (n == NULL)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1550 return -2;
16663 a955e05dd7a0 parsers: allow hex keys Bryan O'Sullivan <bryano@fb.com> parents: 16642 diff changeset	1551 for (i = level; i < maxlevel; i++)
a955e05dd7a0 parsers: allow hex keys Bryan O'Sullivan <bryano@fb.com> parents: 16642 diff changeset	1552 if (getnybble(node, i) != nt_level(n, i))
a955e05dd7a0 parsers: allow hex keys Bryan O'Sullivan <bryano@fb.com> parents: 16642 diff changeset	1553 return -2;
a955e05dd7a0 parsers: allow hex keys Bryan O'Sullivan <bryano@fb.com> parents: 16642 diff changeset	1554 return v;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1555 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1556 if (v == 0)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1557 return -2;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1558 off = v;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1559 }
16616 8f79aabd96f6 parsers: allow nt_find to signal an ambiguous match Bryan O'Sullivan <bryano@fb.com> parents: 16615 diff changeset	1560 /* multiple matches against an ambiguous prefix */
8f79aabd96f6 parsers: allow nt_find to signal an ambiguous match Bryan O'Sullivan <bryano@fb.com> parents: 16615 diff changeset	1561 return -4;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1562 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1563
38915 fff675dfb80b index: pass only nodetree to nt_new() Martin von Zweigbergk <martinvonz@google.com> parents: 38914 diff changeset	1564 static int nt_new(nodetree *self)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1565 {
38915 fff675dfb80b index: pass only nodetree to nt_new() Martin von Zweigbergk <martinvonz@google.com> parents: 38914 diff changeset	1566 if (self->length == self->capacity) {
38938 dcd395dc98d8 index: remove side-effect from failed nt_new() Martin von Zweigbergk <martinvonz@google.com> parents: 38937 diff changeset	1567 unsigned newcapacity;
dcd395dc98d8 index: remove side-effect from failed nt_new() Martin von Zweigbergk <martinvonz@google.com> parents: 38937 diff changeset	1568 nodetreenode *newnodes;
39071 06ff7ea4f440 index: avoid duplicating capacity-growth expression Martin von Zweigbergk <martinvonz@google.com> parents: 39070 diff changeset	1569 newcapacity = self->capacity * 2;
06ff7ea4f440 index: avoid duplicating capacity-growth expression Martin von Zweigbergk <martinvonz@google.com> parents: 39070 diff changeset	1570 if (newcapacity >= INT_MAX / sizeof(nodetreenode)) {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1571 PyErr_SetString(PyExc_MemoryError,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1572 "overflow in nt_new");
24623 2262d7bc469e parsers: check for memory allocation overflows more carefully Bryan O'Sullivan <bryano@fb.com> parents: 24622 diff changeset	1573 return -1;
2262d7bc469e parsers: check for memory allocation overflows more carefully Bryan O'Sullivan <bryano@fb.com> parents: 24622 diff changeset	1574 }
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1575 newnodes =
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1576 realloc(self->nodes, newcapacity * sizeof(nodetreenode));
38938 dcd395dc98d8 index: remove side-effect from failed nt_new() Martin von Zweigbergk <martinvonz@google.com> parents: 38937 diff changeset	1577 if (newnodes == NULL) {
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1578 PyErr_SetString(PyExc_MemoryError, "out of memory");
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1579 return -1;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1580 }
38938 dcd395dc98d8 index: remove side-effect from failed nt_new() Martin von Zweigbergk <martinvonz@google.com> parents: 38937 diff changeset	1581 self->capacity = newcapacity;
dcd395dc98d8 index: remove side-effect from failed nt_new() Martin von Zweigbergk <martinvonz@google.com> parents: 38937 diff changeset	1582 self->nodes = newnodes;
38915 fff675dfb80b index: pass only nodetree to nt_new() Martin von Zweigbergk <martinvonz@google.com> parents: 38914 diff changeset	1583 memset(&self->nodes[self->length], 0,
fff675dfb80b index: pass only nodetree to nt_new() Martin von Zweigbergk <martinvonz@google.com> parents: 38914 diff changeset	1584 sizeof(nodetreenode) * (self->capacity - self->length));
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1585 }
38915 fff675dfb80b index: pass only nodetree to nt_new() Martin von Zweigbergk <martinvonz@google.com> parents: 38914 diff changeset	1586 return self->length++;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1587 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1588
38940 b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1589 static int nt_insert(nodetree self, const char node, int rev)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1590 {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1591 int level = 0;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1592 int off = 0;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1593
16641 e6dfbc5df76f parsers: use the correct maximum radix tree depth Bryan O'Sullivan <bryano@fb.com> parents: 16604 diff changeset	1594 while (level < 40) {
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1595 int k = nt_level(node, level);
38912 d1bc0e7c862b index: extract a type for the nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38911 diff changeset	1596 nodetreenode *n;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1597 int v;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1598
38940 b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1599 n = &self->nodes[off];
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1600 v = n->children[k];
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1601
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1602 if (v == 0) {
38846 f738c502e43b index: store nullrev as -1 in nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38845 diff changeset	1603 n->children[k] = -rev - 2;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1604 return 0;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1605 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1606 if (v < 0) {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1607 const char *oldnode =
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1608 index_node_existing(self->index, -(v + 2));
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1609 int noff;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1610
37999 514605777244 revlog: handle errors from index_node() in nt_insert() and index_slice_del() Martin von Zweigbergk <martinvonz@google.com> parents: 37978 diff changeset	1611 if (oldnode == NULL)
514605777244 revlog: handle errors from index_node() in nt_insert() and index_slice_del() Martin von Zweigbergk <martinvonz@google.com> parents: 37978 diff changeset	1612 return -1;
514605777244 revlog: handle errors from index_node() in nt_insert() and index_slice_del() Martin von Zweigbergk <martinvonz@google.com> parents: 37978 diff changeset	1613 if (!memcmp(oldnode, node, 20)) {
38846 f738c502e43b index: store nullrev as -1 in nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38845 diff changeset	1614 n->children[k] = -rev - 2;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1615 return 0;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1616 }
38940 b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1617 noff = nt_new(self);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1618 if (noff == -1)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1619 return -1;
38940 b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1620 /* self->nodes may have been changed by realloc */
b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1621 self->nodes[off].children[k] = noff;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1622 off = noff;
38940 b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1623 n = &self->nodes[off];
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1624 n->children[nt_level(oldnode, ++level)] = v;
38940 b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1625 if (level > self->depth)
b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1626 self->depth = level;
b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1627 self->splits += 1;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1628 } else {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1629 level += 1;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1630 off = v;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1631 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1632 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1633
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1634 return -1;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1635 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1636
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1637 static PyObject ntobj_insert(nodetreeObject self, PyObject *args)
39226 7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1638 {
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1639 Py_ssize_t rev;
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1640 const char *node;
39227 42cc76d0f836 cext: fix revlog compiler error on Windows Matt Harbison <matt_harbison@yahoo.com> parents: 39226 diff changeset	1641 Py_ssize_t length;
39226 7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1642 if (!PyArg_ParseTuple(args, "n", &rev))
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1643 return NULL;
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1644 length = index_length(self->nt.index);
39226 7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1645 if (rev < 0 \|\| rev >= length) {
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1646 PyErr_SetString(PyExc_ValueError, "revlog index out of range");
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1647 return NULL;
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1648 }
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1649 node = index_node_existing(self->nt.index, rev);
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1650 if (nt_insert(&self->nt, node, (int)rev) == -1)
39226 7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1651 return NULL;
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1652 Py_RETURN_NONE;
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1653 }
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1654
38940 b6fb71a0a005 index: make most "nt_" functions take a nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38939 diff changeset	1655 static int nt_delete_node(nodetree self, const char node)
38845 f9fc59ea3135 index: create function for deleting node from nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38821 diff changeset	1656 {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1657 /* rev==-2 happens to get encoded as 0, which is interpreted as not set
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1658 */
38846 f738c502e43b index: store nullrev as -1 in nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38845 diff changeset	1659 return nt_insert(self, node, -2);
38845 f9fc59ea3135 index: create function for deleting node from nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38821 diff changeset	1660 }
f9fc59ea3135 index: create function for deleting node from nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38821 diff changeset	1661
38941 c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1662 static int nt_init(nodetree self, indexObject index, unsigned capacity)
c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1663 {
39225 fcaffbd7e635 index: fix a comment about overflow-checking Martin von Zweigbergk <martinvonz@google.com> parents: 39219 diff changeset	1664 /* Initialize before overflow-checking to avoid nt_dealloc() crash. */
39218 b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1665 self->nodes = NULL;
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1666
38941 c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1667 self->index = index;
39072 34eb999e29bf index: make capacity argument to nt_init be measured in revisions Martin von Zweigbergk <martinvonz@google.com> parents: 39071 diff changeset	1668 /* The input capacity is in terms of revisions, while the field is in
34eb999e29bf index: make capacity argument to nt_init be measured in revisions Martin von Zweigbergk <martinvonz@google.com> parents: 39071 diff changeset	1669 * terms of nodetree nodes. */
34eb999e29bf index: make capacity argument to nt_init be measured in revisions Martin von Zweigbergk <martinvonz@google.com> parents: 39071 diff changeset	1670 self->capacity = (capacity < 4 ? 4 : capacity / 2);
38941 c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1671 self->depth = 0;
c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1672 self->splits = 0;
39070 4dd92a15fcca index: move check for too large capacity into nt_init() Martin von Zweigbergk <martinvonz@google.com> parents: 39069 diff changeset	1673 if ((size_t)self->capacity > INT_MAX / sizeof(nodetreenode)) {
4dd92a15fcca index: move check for too large capacity into nt_init() Martin von Zweigbergk <martinvonz@google.com> parents: 39069 diff changeset	1674 PyErr_SetString(PyExc_ValueError, "overflow in init_nt");
4dd92a15fcca index: move check for too large capacity into nt_init() Martin von Zweigbergk <martinvonz@google.com> parents: 39069 diff changeset	1675 return -1;
4dd92a15fcca index: move check for too large capacity into nt_init() Martin von Zweigbergk <martinvonz@google.com> parents: 39069 diff changeset	1676 }
38941 c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1677 self->nodes = calloc(self->capacity, sizeof(nodetreenode));
c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1678 if (self->nodes == NULL) {
c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1679 PyErr_NoMemory();
c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1680 return -1;
c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1681 }
c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1682 self->length = 1;
c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1683 return 0;
c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1684 }
c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1685
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1686 static int ntobj_init(nodetreeObject self, PyObject args)
39218 b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1687 {
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1688 PyObject *index;
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1689 unsigned capacity;
40860 18a8def6e1b5 revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol Yuya Nishihara <yuya@tcha.org> parents: 40859 diff changeset	1690 if (!PyArg_ParseTuple(args, "O!I", &HgRevlogIndex_Type, &index,
18a8def6e1b5 revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol Yuya Nishihara <yuya@tcha.org> parents: 40859 diff changeset	1691 &capacity))
39218 b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1692 return -1;
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1693 Py_INCREF(index);
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1694 return nt_init(&self->nt, (indexObject *)index, capacity);
39218 b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1695 }
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1696
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1697 static int nt_partialmatch(nodetree self, const char node, Py_ssize_t nodelen)
38943 2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1698 {
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1699 return nt_find(self, node, nodelen, 1);
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1700 }
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1701
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1702 /*
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1703 * Find the length of the shortest unique prefix of node.
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1704 *
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1705 * Return values:
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1706 *
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1707 * -3: error (exception set)
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1708 * -2: not found (no exception set)
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1709 * rest: length of shortest prefix
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1710 */
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1711 static int nt_shortest(nodetree self, const char node)
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1712 {
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1713 int level, off;
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1714
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1715 for (level = off = 0; level < 40; level++) {
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1716 int k, v;
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1717 nodetreenode *n = &self->nodes[off];
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1718 k = nt_level(node, level);
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1719 v = n->children[k];
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1720 if (v < 0) {
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1721 const char *n;
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1722 v = -(v + 2);
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1723 n = index_node_existing(self->index, v);
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1724 if (n == NULL)
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1725 return -3;
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1726 if (memcmp(node, n, 20) != 0)
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1727 /*
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1728 * Found a unique prefix, but it wasn't for the
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1729 * requested node (i.e the requested node does
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1730 * not exist).
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1731 */
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1732 return -2;
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1733 return level + 1;
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1734 }
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1735 if (v == 0)
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1736 return -2;
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1737 off = v;
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1738 }
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1739 /*
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1740 * The node was still not unique after 40 hex digits, so this won't
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1741 * happen. Also, if we get here, then there's a programming error in
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1742 * this file that made us insert a node longer than 40 hex digits.
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1743 */
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1744 PyErr_SetString(PyExc_Exception, "broken node tree");
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1745 return -3;
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1746 }
2b89e20c450c index: move all "nt_" functions to one place Martin von Zweigbergk <martinvonz@google.com>* parents: 38942 diff changeset	1747
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1748 static PyObject ntobj_shortest(nodetreeObject self, PyObject *args)
39226 7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1749 {
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1750 PyObject *val;
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1751 char *node;
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1752 int length;
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1753
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1754 if (!PyArg_ParseTuple(args, "O", &val))
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1755 return NULL;
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1756 if (node_check(val, &node) == -1)
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1757 return NULL;
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1758
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1759 length = nt_shortest(&self->nt, node);
39226 7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1760 if (length == -3)
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1761 return NULL;
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1762 if (length == -2) {
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1763 raise_revlog_error();
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1764 return NULL;
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1765 }
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1766 return PyInt_FromLong(length);
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1767 }
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1768
39218 b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1769 static void nt_dealloc(nodetree *self)
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1770 {
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1771 free(self->nodes);
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1772 self->nodes = NULL;
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1773 }
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1774
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1775 static void ntobj_dealloc(nodetreeObject *self)
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1776 {
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1777 Py_XDECREF(self->nt.index);
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1778 nt_dealloc(&self->nt);
39218 b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1779 PyObject_Del(self);
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1780 }
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1781
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1782 static PyMethodDef ntobj_methods[] = {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1783 {"insert", (PyCFunction)ntobj_insert, METH_VARARGS,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1784 "insert an index entry"},
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1785 {"shortest", (PyCFunction)ntobj_shortest, METH_VARARGS,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1786 "find length of shortest hex nodeid of a binary ID"},
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1787 {NULL} /* Sentinel */
39226 7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1788 };
7a759ad2d06d shortest: use nodetree for finding shortest node within revset Martin von Zweigbergk <martinvonz@google.com> parents: 39225 diff changeset	1789
39218 b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1790 static PyTypeObject nodetreeType = {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1791 PyVarObject_HEAD_INIT(NULL, 0) /* header */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1792 "parsers.nodetree", /* tp_name */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1793 sizeof(nodetreeObject), /* tp_basicsize */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1794 0, /* tp_itemsize */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1795 (destructor)ntobj_dealloc, /* tp_dealloc */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1796 0, /* tp_print */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1797 0, /* tp_getattr */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1798 0, /* tp_setattr */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1799 0, /* tp_compare */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1800 0, /* tp_repr */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1801 0, /* tp_as_number */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1802 0, /* tp_as_sequence */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1803 0, /* tp_as_mapping */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1804 0, /* tp_hash */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1805 0, /* tp_call */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1806 0, /* tp_str */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1807 0, /* tp_getattro */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1808 0, /* tp_setattro */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1809 0, /* tp_as_buffer */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1810 Py_TPFLAGS_DEFAULT, /* tp_flags */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1811 "nodetree", /* tp_doc */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1812 0, /* tp_traverse */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1813 0, /* tp_clear */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1814 0, /* tp_richcompare */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1815 0, /* tp_weaklistoffset */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1816 0, /* tp_iter */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1817 0, /* tp_iternext */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1818 ntobj_methods, /* tp_methods */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1819 0, /* tp_members */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1820 0, /* tp_getset */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1821 0, /* tp_base */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1822 0, /* tp_dict */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1823 0, /* tp_descr_get */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1824 0, /* tp_descr_set */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1825 0, /* tp_dictoffset */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1826 (initproc)ntobj_init, /* tp_init */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1827 0, /* tp_alloc */
39218 b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1828 };
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	1829
38941 c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1830 static int index_init_nt(indexObject *self)
16615 96fa9dd1db38 parsers: factor out radix tree initialization Bryan O'Sullivan <bryano@fb.com> parents: 16614 diff changeset	1831 {
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1832 if (!self->ntinitialized) {
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1833 if (nt_init(&self->nt, self, (int)self->raw_length) == -1) {
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1834 nt_dealloc(&self->nt);
38912 d1bc0e7c862b index: extract a type for the nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38911 diff changeset	1835 return -1;
d1bc0e7c862b index: extract a type for the nodetree Martin von Zweigbergk <martinvonz@google.com> parents: 38911 diff changeset	1836 }
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1837 if (nt_insert(&self->nt, nullid, -1) == -1) {
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1838 nt_dealloc(&self->nt);
16615 96fa9dd1db38 parsers: factor out radix tree initialization Bryan O'Sullivan <bryano@fb.com> parents: 16614 diff changeset	1839 return -1;
96fa9dd1db38 parsers: factor out radix tree initialization Bryan O'Sullivan <bryano@fb.com> parents: 16614 diff changeset	1840 }
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1841 self->ntinitialized = 1;
38851 781b2720d2ac index: don't include nullid in len() Martin von Zweigbergk <martinvonz@google.com> parents: 38850 diff changeset	1842 self->ntrev = (int)index_length(self);
16615 96fa9dd1db38 parsers: factor out radix tree initialization Bryan O'Sullivan <bryano@fb.com> parents: 16614 diff changeset	1843 self->ntlookups = 1;
96fa9dd1db38 parsers: factor out radix tree initialization Bryan O'Sullivan <bryano@fb.com> parents: 16614 diff changeset	1844 self->ntmisses = 0;
96fa9dd1db38 parsers: factor out radix tree initialization Bryan O'Sullivan <bryano@fb.com> parents: 16614 diff changeset	1845 }
96fa9dd1db38 parsers: factor out radix tree initialization Bryan O'Sullivan <bryano@fb.com> parents: 16614 diff changeset	1846 return 0;
96fa9dd1db38 parsers: factor out radix tree initialization Bryan O'Sullivan <bryano@fb.com> parents: 16614 diff changeset	1847 }
96fa9dd1db38 parsers: factor out radix tree initialization Bryan O'Sullivan <bryano@fb.com> parents: 16614 diff changeset	1848
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1849 /*
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1850 * Return values:
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1851 *
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1852 * -3: error (exception set)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1853 * -2: not found (no exception set)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1854 * rest: valid rev
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1855 */
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1856 static int index_find_node(indexObject self, const char node,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1857 Py_ssize_t nodelen)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1858 {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1859 int rev;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1860
38941 c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1861 if (index_init_nt(self) == -1)
38820 44bbc89ec5e0 revlog: remove micro-optimization for looking up only nullid Martin von Zweigbergk <martinvonz@google.com> parents: 38819 diff changeset	1862 return -3;
44bbc89ec5e0 revlog: remove micro-optimization for looking up only nullid Martin von Zweigbergk <martinvonz@google.com> parents: 38819 diff changeset	1863
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1864 self->ntlookups++;
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1865 rev = nt_find(&self->nt, node, nodelen, 0);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1866 if (rev >= -1)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1867 return rev;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1868
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1869 /*
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1870 * For the first handful of lookups, we scan the entire index,
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1871 * and cache only the matching nodes. This optimizes for cases
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1872 * like "hg tip", where only a few nodes are accessed.
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1873 *
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1874 * After that, we cache every node we visit, using a single
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1875 * scan amortized over multiple lookups. This gives the best
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1876 * bulk performance, e.g. for "hg log".
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1877 */
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1878 if (self->ntmisses++ < 4) {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1879 for (rev = self->ntrev - 1; rev >= 0; rev--) {
37861 a9d9802d577e revlog: don't say "not found" on internal error Martin von Zweigbergk <martinvonz@google.com> parents: 37860 diff changeset	1880 const char *n = index_node_existing(self, rev);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1881 if (n == NULL)
37861 a9d9802d577e revlog: don't say "not found" on internal error Martin von Zweigbergk <martinvonz@google.com> parents: 37860 diff changeset	1882 return -3;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1883 if (memcmp(node, n, nodelen > 20 ? 20 : nodelen) == 0) {
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1884 if (nt_insert(&self->nt, n, rev) == -1)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1885 return -3;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1886 break;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1887 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1888 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1889 } else {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1890 for (rev = self->ntrev - 1; rev >= 0; rev--) {
37861 a9d9802d577e revlog: don't say "not found" on internal error Martin von Zweigbergk <martinvonz@google.com> parents: 37860 diff changeset	1891 const char *n = index_node_existing(self, rev);
a9d9802d577e revlog: don't say "not found" on internal error Martin von Zweigbergk <martinvonz@google.com> parents: 37860 diff changeset	1892 if (n == NULL)
a9d9802d577e revlog: don't say "not found" on internal error Martin von Zweigbergk <martinvonz@google.com> parents: 37860 diff changeset	1893 return -3;
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1894 if (nt_insert(&self->nt, n, rev) == -1) {
16614 1d800eb9ba52 parsers: update ntrev when we stop scanning Bryan O'Sullivan <bryano@fb.com> parents: 16597 diff changeset	1895 self->ntrev = rev + 1;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1896 return -3;
16614 1d800eb9ba52 parsers: update ntrev when we stop scanning Bryan O'Sullivan <bryano@fb.com> parents: 16597 diff changeset	1897 }
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1898 if (memcmp(node, n, nodelen > 20 ? 20 : nodelen) == 0) {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1899 break;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1900 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1901 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1902 self->ntrev = rev;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1903 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1904
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1905 if (rev >= 0)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1906 return rev;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1907 return -2;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1908 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1909
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1910 static PyObject index_getitem(indexObject self, PyObject *value)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1911 {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1912 char *node;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1913 int rev;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1914
40598 fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	1915 if (PyInt_Check(value)) {
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	1916 long idx;
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	1917 if (!pylong_to_long(value, &idx)) {
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	1918 return NULL;
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	1919 }
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	1920 return index_get(self, idx);
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	1921 }
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1922
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	1923 if (node_check(value, &node) == -1)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1924 return NULL;
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	1925 rev = index_find_node(self, node, 20);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1926 if (rev >= -1)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1927 return PyInt_FromLong(rev);
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1928 if (rev == -2)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1929 raise_revlog_error();
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1930 return NULL;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1931 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	1932
37929 9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1933 /*
9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1934 * Fully populate the radix tree.
9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1935 */
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1936 static int index_populate_nt(indexObject *self)
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	1937 {
37929 9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1938 int rev;
9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1939 if (self->ntrev > 0) {
9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1940 for (rev = self->ntrev - 1; rev >= 0; rev--) {
9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1941 const char *n = index_node_existing(self, rev);
9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1942 if (n == NULL)
9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1943 return -1;
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1944 if (nt_insert(&self->nt, n, rev) == -1)
37929 9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1945 return -1;
9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1946 }
37930 892592475094 revlog: use literal -1 instead of variable that always has that value Martin von Zweigbergk <martinvonz@google.com> parents: 37929 diff changeset	1947 self->ntrev = -1;
37929 9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1948 }
9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1949 return 0;
9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1950 }
9c6d1d41b3e6 revlog: extract function for fully populating the radix tree Martin von Zweigbergk <martinvonz@google.com> parents: 37861 diff changeset	1951
16665 e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1952 static PyObject index_partialmatch(indexObject self, PyObject *args)
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1953 {
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1954 const char *fullnode;
42067 b01bbb8ff1f2 cext: make revlog.c PY_SSIZE_T_CLEAN Gregory Szorc <gregory.szorc@gmail.com> parents: 41283 diff changeset	1955 Py_ssize_t nodelen;
16665 e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1956 char *node;
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1957 int rev, i;
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1958
36620 186c6df3a373 py3: bulk-replace 'const char' format specifier passed to PyArg_ParseTuple() Yuya Nishihara <yuya@tcha.org> parents: 36619 diff changeset	1959 if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &node, &nodelen))
16665 e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1960 return NULL;
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1961
37858 92ed344a9e64 revlog: use radix tree also for matching keys shorter than 4 hex digits Martin von Zweigbergk <martinvonz@google.com> parents: 36623 diff changeset	1962 if (nodelen < 1) {
16665 e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1963 PyErr_SetString(PyExc_ValueError, "key too short");
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1964 return NULL;
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1965 }
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1966
17353 bde1185f406c revlog: don't try to partialmatch strings those length > 40 sorcerer parents: 17165 diff changeset	1967 if (nodelen > 40) {
bde1185f406c revlog: don't try to partialmatch strings those length > 40 sorcerer parents: 17165 diff changeset	1968 PyErr_SetString(PyExc_ValueError, "key too long");
bde1185f406c revlog: don't try to partialmatch strings those length > 40 sorcerer parents: 17165 diff changeset	1969 return NULL;
bde1185f406c revlog: don't try to partialmatch strings those length > 40 sorcerer parents: 17165 diff changeset	1970 }
16665 e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1971
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1972 for (i = 0; i < nodelen; i++)
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1973 hexdigit(node, i);
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1974 if (PyErr_Occurred()) {
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1975 /* input contains non-hex characters */
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1976 PyErr_Clear();
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1977 Py_RETURN_NONE;
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1978 }
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1979
38941 c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	1980 if (index_init_nt(self) == -1)
38911 2aa4f06c1e91 index: make "nt_" functions work on an initialized nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38868 diff changeset	1981 return NULL;
38942 3e74c01102af index: rename "nt_(indexObject self,...)" functions to "index_" Martin von Zweigbergk <martinvonz@google.com>* parents: 38941 diff changeset	1982 if (index_populate_nt(self) == -1)
38911 2aa4f06c1e91 index: make "nt_" functions work on an initialized nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38868 diff changeset	1983 return NULL;
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	1984 rev = nt_partialmatch(&self->nt, node, nodelen);
16665 e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1985
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1986 switch (rev) {
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1987 case -4:
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1988 raise_revlog_error();
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1989 return NULL;
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1990 case -2:
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1991 Py_RETURN_NONE;
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1992 case -1:
30100 c5afe5531709 parsers: convert PyString* to PyBytes* Gregory Szorc <gregory.szorc@gmail.com> parents: 30090 diff changeset	1993 return PyBytes_FromStringAndSize(nullid, 20);
16665 e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1994 }
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1995
37860 a91f31a1e281 revlog: extract function for getting node from known-to-exist rev Martin von Zweigbergk <martinvonz@google.com> parents: 37858 diff changeset	1996 fullnode = index_node_existing(self, rev);
16665 e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1997 if (fullnode == NULL) {
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1998 return NULL;
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	1999 }
30100 c5afe5531709 parsers: convert PyString* to PyBytes* Gregory Szorc <gregory.szorc@gmail.com> parents: 30090 diff changeset	2000 return PyBytes_FromStringAndSize(fullnode, 20);
16665 e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	2001 }
e410be860393 revlog: speed up prefix matching against nodes Bryan O'Sullivan <bryano@fb.com> parents: 16664 diff changeset	2002
37968 0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2003 static PyObject index_shortest(indexObject self, PyObject *args)
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2004 {
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2005 PyObject *val;
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2006 char *node;
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2007 int length;
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2008
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2009 if (!PyArg_ParseTuple(args, "O", &val))
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2010 return NULL;
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	2011 if (node_check(val, &node) == -1)
37968 0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2012 return NULL;
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2013
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2014 self->ntlookups++;
38941 c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	2015 if (index_init_nt(self) == -1)
38911 2aa4f06c1e91 index: make "nt_" functions work on an initialized nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38868 diff changeset	2016 return NULL;
38942 3e74c01102af index: rename "nt_(indexObject self,...)" functions to "index_" Martin von Zweigbergk <martinvonz@google.com>* parents: 38941 diff changeset	2017 if (index_populate_nt(self) == -1)
38911 2aa4f06c1e91 index: make "nt_" functions work on an initialized nodetree Martin von Zweigbergk <martinvonz@google.com>* parents: 38868 diff changeset	2018 return NULL;
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	2019 length = nt_shortest(&self->nt, node);
37968 0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2020 if (length == -3)
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2021 return NULL;
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2022 if (length == -2) {
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2023 raise_revlog_error();
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2024 return NULL;
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2025 }
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2026 return PyInt_FromLong(length);
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2027 }
0304f22497fa revlog: use node tree (native code) for shortest() calculation Martin von Zweigbergk <martinvonz@google.com> parents: 37930 diff changeset	2028
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2029 static PyObject index_m_get(indexObject self, PyObject *args)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2030 {
16679 2950d186a927 parsers: strictly check for 20-byte hashes where they're required Bryan O'Sullivan <bryano@fb.com> parents: 16641 diff changeset	2031 PyObject *val;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2032 char *node;
16679 2950d186a927 parsers: strictly check for 20-byte hashes where they're required Bryan O'Sullivan <bryano@fb.com> parents: 16641 diff changeset	2033 int rev;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2034
16679 2950d186a927 parsers: strictly check for 20-byte hashes where they're required Bryan O'Sullivan <bryano@fb.com> parents: 16641 diff changeset	2035 if (!PyArg_ParseTuple(args, "O", &val))
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2036 return NULL;
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	2037 if (node_check(val, &node) == -1)
16679 2950d186a927 parsers: strictly check for 20-byte hashes where they're required Bryan O'Sullivan <bryano@fb.com> parents: 16641 diff changeset	2038 return NULL;
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	2039 rev = index_find_node(self, node, 20);
27638 90e3c5129226 cleanup: remove superfluous space after space after equals (C) timeless <timeless@mozdev.org> parents: 27592 diff changeset	2040 if (rev == -3)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2041 return NULL;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2042 if (rev == -2)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2043 Py_RETURN_NONE;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2044 return PyInt_FromLong(rev);
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2045 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2046
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2047 static int index_contains(indexObject self, PyObject value)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2048 {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2049 char *node;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2050
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2051 if (PyInt_Check(value)) {
40598 fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	2052 long rev;
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	2053 if (!pylong_to_long(value, &rev)) {
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	2054 return -1;
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	2055 }
38866 aa33988ad8ab index: return False for "len(index) in index" Martin von Zweigbergk <martinvonz@google.com> parents: 38852 diff changeset	2056 return rev >= -1 && rev < index_length(self);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2057 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2058
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	2059 if (node_check(value, &node) == -1)
16679 2950d186a927 parsers: strictly check for 20-byte hashes where they're required Bryan O'Sullivan <bryano@fb.com> parents: 16641 diff changeset	2060 return -1;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2061
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	2062 switch (index_find_node(self, node, 20)) {
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2063 case -3:
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2064 return -1;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2065 case -2:
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2066 return 0;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2067 default:
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2068 return 1;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2069 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2070 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2071
43534 0c659fc20207 index: add a `has_node` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43532 diff changeset	2072 static PyObject index_m_has_node(indexObject self, PyObject *args)
0c659fc20207 index: add a `has_node` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43532 diff changeset	2073 {
0c659fc20207 index: add a `has_node` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43532 diff changeset	2074 int ret = index_contains(self, args);
0c659fc20207 index: add a `has_node` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43532 diff changeset	2075 if (ret < 0)
0c659fc20207 index: add a `has_node` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43532 diff changeset	2076 return NULL;
0c659fc20207 index: add a `has_node` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43532 diff changeset	2077 return PyBool_FromLong((long)ret);
0c659fc20207 index: add a `has_node` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43532 diff changeset	2078 }
0c659fc20207 index: add a `has_node` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43532 diff changeset	2079
43552 bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2080 static PyObject index_m_rev(indexObject self, PyObject *val)
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2081 {
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2082 char *node;
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2083 int rev;
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2084
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2085 if (node_check(val, &node) == -1)
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2086 return NULL;
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2087 rev = index_find_node(self, node, 20);
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2088 if (rev >= -1)
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2089 return PyInt_FromLong(rev);
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2090 if (rev == -2)
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2091 raise_revlog_error();
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2092 return NULL;
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2093 }
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2094
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2095 typedef uint64_t bitmask;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2096
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2097 /*
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2098 * Given a disjoint set of revs, return all candidates for the
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2099 * greatest common ancestor. In revset notation, this is the set
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2100 * "heads(::a and ::b and ...)"
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2101 */
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2102 static PyObject find_gca_candidates(indexObject self, const int *revs,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2103 int revcount)
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2104 {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2105 const bitmask allseen = (1ull << revcount) - 1;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2106 const bitmask poison = 1ull << revcount;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2107 PyObject *gca = PyList_New(0);
20555 4add43865a9b ancestors: remove unnecessary handling of 'left' Mads Kiilerich <madski@unity3d.com> parents: 20554 diff changeset	2108 int i, v, interesting;
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2109 int maxrev = -1;
22399 9f490afcb067 parsers: use bitmask type consistently in find_gca_candidates Henrik Stuart <hg@hstuart.dk> parents: 21871 diff changeset	2110 bitmask sp;
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2111 bitmask *seen;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2112
19727 3d07b4a2f743 parsers: correctly handle a failed allocation Bryan O'Sullivan <bryano@fb.com> parents: 19726 diff changeset	2113 if (gca == NULL)
3d07b4a2f743 parsers: correctly handle a failed allocation Bryan O'Sullivan <bryano@fb.com> parents: 19726 diff changeset	2114 return PyErr_NoMemory();
3d07b4a2f743 parsers: correctly handle a failed allocation Bryan O'Sullivan <bryano@fb.com> parents: 19726 diff changeset	2115
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2116 for (i = 0; i < revcount; i++) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2117 if (revs[i] > maxrev)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2118 maxrev = revs[i];
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2119 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2120
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2121 seen = calloc(sizeof(*seen), maxrev + 1);
19727 3d07b4a2f743 parsers: correctly handle a failed allocation Bryan O'Sullivan <bryano@fb.com> parents: 19726 diff changeset	2122 if (seen == NULL) {
3d07b4a2f743 parsers: correctly handle a failed allocation Bryan O'Sullivan <bryano@fb.com> parents: 19726 diff changeset	2123 Py_DECREF(gca);
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2124 return PyErr_NoMemory();
19727 3d07b4a2f743 parsers: correctly handle a failed allocation Bryan O'Sullivan <bryano@fb.com> parents: 19726 diff changeset	2125 }
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2126
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2127 for (i = 0; i < revcount; i++)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2128 seen[revs[i]] = 1ull << i;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2129
20555 4add43865a9b ancestors: remove unnecessary handling of 'left' Mads Kiilerich <madski@unity3d.com> parents: 20554 diff changeset	2130 interesting = revcount;
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2131
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2132 for (v = maxrev; v >= 0 && interesting; v--) {
22399 9f490afcb067 parsers: use bitmask type consistently in find_gca_candidates Henrik Stuart <hg@hstuart.dk> parents: 21871 diff changeset	2133 bitmask sv = seen[v];
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2134 int parents[2];
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2135
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2136 if (!sv)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2137 continue;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2138
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2139 if (sv < poison) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2140 interesting -= 1;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2141 if (sv == allseen) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2142 PyObject *obj = PyInt_FromLong(v);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2143 if (obj == NULL)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2144 goto bail;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2145 if (PyList_Append(gca, obj) == -1) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2146 Py_DECREF(obj);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2147 goto bail;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2148 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2149 sv \|= poison;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2150 for (i = 0; i < revcount; i++) {
20555 4add43865a9b ancestors: remove unnecessary handling of 'left' Mads Kiilerich <madski@unity3d.com> parents: 20554 diff changeset	2151 if (revs[i] == v)
4add43865a9b ancestors: remove unnecessary handling of 'left' Mads Kiilerich <madski@unity3d.com> parents: 20554 diff changeset	2152 goto done;
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2153 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2154 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2155 }
25810 82d6a35cf432 parsers: fix buffer overflow by invalid parent revision read from revlog Yuya Nishihara <yuya@tcha.org> parents: 25584 diff changeset	2156 if (index_get_parents(self, v, parents, maxrev) < 0)
82d6a35cf432 parsers: fix buffer overflow by invalid parent revision read from revlog Yuya Nishihara <yuya@tcha.org> parents: 25584 diff changeset	2157 goto bail;
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2158
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2159 for (i = 0; i < 2; i++) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2160 int p = parents[i];
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2161 if (p == -1)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2162 continue;
19030 48d6f436363e parsers: fix variable declaration position issue Matt Mackall <mpm@selenic.com> parents: 18988 diff changeset	2163 sp = seen[p];
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2164 if (sv < poison) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2165 if (sp == 0) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2166 seen[p] = sv;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2167 interesting++;
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2168 } else if (sp != sv)
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2169 seen[p] \|= sv;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2170 } else {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2171 if (sp && sp < poison)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2172 interesting--;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2173 seen[p] = sv;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2174 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2175 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2176 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2177
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2178 done:
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2179 free(seen);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2180 return gca;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2181 bail:
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2182 free(seen);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2183 Py_XDECREF(gca);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2184 return NULL;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2185 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2186
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2187 /*
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2188 * Given a disjoint set of revs, return the subset with the longest
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2189 * path to the root.
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2190 */
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2191 static PyObject find_deepest(indexObject self, PyObject *revs)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2192 {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2193 const Py_ssize_t revcount = PyList_GET_SIZE(revs);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2194 static const Py_ssize_t capacity = 24;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2195 int depth, interesting = NULL;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2196 int i, j, v, ninteresting;
21730 8da100383dc3 parsers.c: fix a couple of memory leaks Danek Duvall <danek.duvall@oracle.com> parents: 21103 diff changeset	2197 PyObject dict = NULL, keys = NULL;
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2198 long *seen = NULL;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2199 int maxrev = -1;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2200 long final;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2201
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2202 if (revcount > capacity) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2203 PyErr_Format(PyExc_OverflowError,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2204 "bitset size (%ld) > capacity (%ld)",
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2205 (long)revcount, (long)capacity);
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2206 return NULL;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2207 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2208
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2209 for (i = 0; i < revcount; i++) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2210 int n = (int)PyInt_AsLong(PyList_GET_ITEM(revs, i));
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2211 if (n > maxrev)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2212 maxrev = n;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2213 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2214
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2215 depth = calloc(sizeof(*depth), maxrev + 1);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2216 if (depth == NULL)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2217 return PyErr_NoMemory();
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2218
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2219 seen = calloc(sizeof(*seen), maxrev + 1);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2220 if (seen == NULL) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2221 PyErr_NoMemory();
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2222 goto bail;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2223 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2224
39073 beab6690f202 cext: fix Windows warning about implicit conversion of 32-bit shift to 64 bit Matt Harbison <matt_harbison@yahoo.com> parents: 39072 diff changeset	2225 interesting = calloc(sizeof(*interesting), ((size_t)1) << revcount);
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2226 if (interesting == NULL) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2227 PyErr_NoMemory();
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2228 goto bail;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2229 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2230
19502 8704477ad3b6 ancestor.deepest: sort revs in C version Siddharth Agarwal <sid0@fb.com> parents: 19062 diff changeset	2231 if (PyList_Sort(revs) == -1)
8704477ad3b6 ancestor.deepest: sort revs in C version Siddharth Agarwal <sid0@fb.com> parents: 19062 diff changeset	2232 goto bail;
8704477ad3b6 ancestor.deepest: sort revs in C version Siddharth Agarwal <sid0@fb.com> parents: 19062 diff changeset	2233
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2234 for (i = 0; i < revcount; i++) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2235 int n = (int)PyInt_AsLong(PyList_GET_ITEM(revs, i));
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2236 long b = 1l << i;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2237 depth[n] = 1;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2238 seen[n] = b;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2239 interesting[b] = 1;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2240 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2241
33475 f501322512b6 parsers: fix invariant bug in find_deepest (issue5623) Sune Foldager <cryo@cyanite.org> parents: 33174 diff changeset	2242 /* invariant: ninteresting is the number of non-zero entries in
f501322512b6 parsers: fix invariant bug in find_deepest (issue5623) Sune Foldager <cryo@cyanite.org> parents: 33174 diff changeset	2243 * interesting. */
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2244 ninteresting = (int)revcount;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2245
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2246 for (v = maxrev; v >= 0 && ninteresting > 1; v--) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2247 int dv = depth[v];
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2248 int parents[2];
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2249 long sv;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2250
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2251 if (dv == 0)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2252 continue;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2253
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2254 sv = seen[v];
25810 82d6a35cf432 parsers: fix buffer overflow by invalid parent revision read from revlog Yuya Nishihara <yuya@tcha.org> parents: 25584 diff changeset	2255 if (index_get_parents(self, v, parents, maxrev) < 0)
82d6a35cf432 parsers: fix buffer overflow by invalid parent revision read from revlog Yuya Nishihara <yuya@tcha.org> parents: 25584 diff changeset	2256 goto bail;
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2257
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2258 for (i = 0; i < 2; i++) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2259 int p = parents[i];
27341 5042b999ef0a parsers: narrow scope of a variable to be less confusing Bryan O'Sullivan <bos@serpentine.com> parents: 27226 diff changeset	2260 long sp;
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2261 int dp;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2262
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2263 if (p == -1)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2264 continue;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2265
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2266 dp = depth[p];
27341 5042b999ef0a parsers: narrow scope of a variable to be less confusing Bryan O'Sullivan <bos@serpentine.com> parents: 27226 diff changeset	2267 sp = seen[p];
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2268 if (dp <= dv) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2269 depth[p] = dv + 1;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2270 if (sp != sv) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2271 interesting[sv] += 1;
27341 5042b999ef0a parsers: narrow scope of a variable to be less confusing Bryan O'Sullivan <bos@serpentine.com> parents: 27226 diff changeset	2272 seen[p] = sv;
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2273 if (sp) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2274 interesting[sp] -= 1;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2275 if (interesting[sp] == 0)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2276 ninteresting -= 1;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2277 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2278 }
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2279 } else if (dv == dp - 1) {
27341 5042b999ef0a parsers: narrow scope of a variable to be less confusing Bryan O'Sullivan <bos@serpentine.com> parents: 27226 diff changeset	2280 long nsp = sp \| sv;
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2281 if (nsp == sp)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2282 continue;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2283 seen[p] = nsp;
19503 f2dfda6ac152 ancestor.deepest: decrement ninteresting correctly (issue3984) Wei, Elson <elson.wei@gmail.com> parents: 19502 diff changeset	2284 interesting[sp] -= 1;
33475 f501322512b6 parsers: fix invariant bug in find_deepest (issue5623) Sune Foldager <cryo@cyanite.org> parents: 33174 diff changeset	2285 if (interesting[sp] == 0)
19503 f2dfda6ac152 ancestor.deepest: decrement ninteresting correctly (issue3984) Wei, Elson <elson.wei@gmail.com> parents: 19502 diff changeset	2286 ninteresting -= 1;
33475 f501322512b6 parsers: fix invariant bug in find_deepest (issue5623) Sune Foldager <cryo@cyanite.org> parents: 33174 diff changeset	2287 if (interesting[nsp] == 0)
f501322512b6 parsers: fix invariant bug in find_deepest (issue5623) Sune Foldager <cryo@cyanite.org> parents: 33174 diff changeset	2288 ninteresting += 1;
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2289 interesting[nsp] += 1;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2290 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2291 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2292 interesting[sv] -= 1;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2293 if (interesting[sv] == 0)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2294 ninteresting -= 1;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2295 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2296
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2297 final = 0;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2298 j = ninteresting;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2299 for (i = 0; i < (int)(2 << revcount) && j > 0; i++) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2300 if (interesting[i] == 0)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2301 continue;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2302 final \|= i;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2303 j -= 1;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2304 }
21730 8da100383dc3 parsers.c: fix a couple of memory leaks Danek Duvall <danek.duvall@oracle.com> parents: 21103 diff changeset	2305 if (final == 0) {
8da100383dc3 parsers.c: fix a couple of memory leaks Danek Duvall <danek.duvall@oracle.com> parents: 21103 diff changeset	2306 keys = PyList_New(0);
8da100383dc3 parsers.c: fix a couple of memory leaks Danek Duvall <danek.duvall@oracle.com> parents: 21103 diff changeset	2307 goto bail;
8da100383dc3 parsers.c: fix a couple of memory leaks Danek Duvall <danek.duvall@oracle.com> parents: 21103 diff changeset	2308 }
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2309
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2310 dict = PyDict_New();
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2311 if (dict == NULL)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2312 goto bail;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2313
19504 2fa303619b4d ancestor.deepest: ignore ninteresting while building result (issue3984) Siddharth Agarwal <sid0@fb.com> parents: 19503 diff changeset	2314 for (i = 0; i < revcount; i++) {
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2315 PyObject *key;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2316
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2317 if ((final & (1 << i)) == 0)
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2318 continue;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2319
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2320 key = PyList_GET_ITEM(revs, i);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2321 Py_INCREF(key);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2322 Py_INCREF(Py_None);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2323 if (PyDict_SetItem(dict, key, Py_None) == -1) {
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2324 Py_DECREF(key);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2325 Py_DECREF(Py_None);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2326 goto bail;
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2327 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2328 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2329
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2330 keys = PyDict_Keys(dict);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2331
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2332 bail:
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2333 free(depth);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2334 free(seen);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2335 free(interesting);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2336 Py_XDECREF(dict);
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2337
21730 8da100383dc3 parsers.c: fix a couple of memory leaks Danek Duvall <danek.duvall@oracle.com> parents: 21103 diff changeset	2338 return keys;
18988 5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2339 }
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2340
5bae936764bb parsers: a C implementation of the new ancestors algorithm Bryan O'Sullivan <bryano@fb.com> parents: 18900 diff changeset	2341 /*
21102 4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2342 * Given a (possibly overlapping) set of revs, return all the
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2343 * common ancestors heads: heads(::args[0] and ::a[1] and ...)
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2344 */
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2345 static PyObject index_commonancestorsheads(indexObject self, PyObject *args)
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2346 {
21103 628c16489d1c parsers: remove unnecessary gca variable in index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 21102 diff changeset	2347 PyObject *ret = NULL;
21102 4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2348 Py_ssize_t argcount, i, len;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2349 bitmask repeat = 0;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2350 int revcount = 0;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2351 int *revs;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2352
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2353 argcount = PySequence_Length(args);
31469 a43fd9ec2a39 parsers: use Python memory allocator in commonancestorsheads() Gregory Szorc <gregory.szorc@gmail.com> parents: 31426 diff changeset	2354 revs = PyMem_Malloc(argcount * sizeof(*revs));
21102 4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2355 if (argcount > 0 && revs == NULL)
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2356 return PyErr_NoMemory();
38851 781b2720d2ac index: don't include nullid in len() Martin von Zweigbergk <martinvonz@google.com> parents: 38850 diff changeset	2357 len = index_length(self);
21102 4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2358
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2359 for (i = 0; i < argcount; i++) {
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2360 static const int capacity = 24;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2361 PyObject *obj = PySequence_GetItem(args, i);
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2362 bitmask x;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2363 long val;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2364
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2365 if (!PyInt_Check(obj)) {
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2366 PyErr_SetString(PyExc_TypeError,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2367 "arguments must all be ints");
23945 33d6aaf84c9e parsers.c: fix a memory leak in index_commonancestorsheads Augie Fackler <augie@google.com> parents: 23944 diff changeset	2368 Py_DECREF(obj);
21102 4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2369 goto bail;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2370 }
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2371 val = PyInt_AsLong(obj);
23945 33d6aaf84c9e parsers.c: fix a memory leak in index_commonancestorsheads Augie Fackler <augie@google.com> parents: 23944 diff changeset	2372 Py_DECREF(obj);
21102 4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2373 if (val == -1) {
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2374 ret = PyList_New(0);
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2375 goto done;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2376 }
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2377 if (val < 0 \|\| val >= len) {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2378 PyErr_SetString(PyExc_IndexError, "index out of range");
21102 4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2379 goto bail;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2380 }
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2381 /* this cheesy bloom filter lets us avoid some more
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2382 * expensive duplicate checks in the common set-is-disjoint
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2383 * case */
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2384 x = 1ull << (val & 0x3f);
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2385 if (repeat & x) {
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2386 int k;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2387 for (k = 0; k < revcount; k++) {
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2388 if (val == revs[k])
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2389 goto duplicate;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2390 }
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2391 } else
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2392 repeat \|= x;
21102 4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2393 if (revcount >= capacity) {
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2394 PyErr_Format(PyExc_OverflowError,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2395 "bitset size (%d) > capacity (%d)",
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2396 revcount, capacity);
21102 4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2397 goto bail;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2398 }
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2399 revs[revcount++] = (int)val;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2400 duplicate:;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2401 }
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2402
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2403 if (revcount == 0) {
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2404 ret = PyList_New(0);
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2405 goto done;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2406 }
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2407 if (revcount == 1) {
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2408 PyObject *obj;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2409 ret = PyList_New(1);
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2410 if (ret == NULL)
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2411 goto bail;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2412 obj = PyInt_FromLong(revs[0]);
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2413 if (obj == NULL)
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2414 goto bail;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2415 PyList_SET_ITEM(ret, 0, obj);
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2416 goto done;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2417 }
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2418
21103 628c16489d1c parsers: remove unnecessary gca variable in index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 21102 diff changeset	2419 ret = find_gca_candidates(self, revs, revcount);
628c16489d1c parsers: remove unnecessary gca variable in index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 21102 diff changeset	2420 if (ret == NULL)
21102 4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2421 goto bail;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2422
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2423 done:
31469 a43fd9ec2a39 parsers: use Python memory allocator in commonancestorsheads() Gregory Szorc <gregory.szorc@gmail.com> parents: 31426 diff changeset	2424 PyMem_Free(revs);
21102 4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2425 return ret;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2426
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2427 bail:
31469 a43fd9ec2a39 parsers: use Python memory allocator in commonancestorsheads() Gregory Szorc <gregory.szorc@gmail.com> parents: 31426 diff changeset	2428 PyMem_Free(revs);
21102 4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2429 Py_XDECREF(ret);
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2430 return NULL;
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2431 }
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2432
4eb6553789e1 parsers: introduce index_commonancestorsheads Mads Kiilerich <madski@unity3d.com> parents: 20797 diff changeset	2433 /*
24004 8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2434 * Given a (possibly overlapping) set of revs, return the greatest
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2435 * common ancestors: those with the longest path to the root.
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2436 */
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2437 static PyObject index_ancestors(indexObject self, PyObject *args)
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2438 {
26048 0be2f81aadc3 parsers: fix two leaks in index_ancestors Augie Fackler <augie@google.com> parents: 26044 diff changeset	2439 PyObject *ret;
24004 8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2440 PyObject *gca = index_commonancestorsheads(self, args);
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2441 if (gca == NULL)
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2442 return NULL;
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2443
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2444 if (PyList_GET_SIZE(gca) <= 1) {
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2445 return gca;
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2446 }
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2447
26048 0be2f81aadc3 parsers: fix two leaks in index_ancestors Augie Fackler <augie@google.com> parents: 26044 diff changeset	2448 ret = find_deepest(self, gca);
0be2f81aadc3 parsers: fix two leaks in index_ancestors Augie Fackler <augie@google.com> parents: 26044 diff changeset	2449 Py_DECREF(gca);
0be2f81aadc3 parsers: fix two leaks in index_ancestors Augie Fackler <augie@google.com> parents: 26044 diff changeset	2450 return ret;
24004 8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2451 }
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2452
8a5267cd5286 parsers: rewrite index_ancestors() in terms of index_commonancestorsheads() Martin von Zweigbergk <martinvonz@google.com> parents: 23948 diff changeset	2453 /*
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2454 * Invalidate any trie entries introduced by added revs.
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2455 */
38942 3e74c01102af index: rename "nt_(indexObject self,...)" functions to "index_" Martin von Zweigbergk <martinvonz@google.com>* parents: 38941 diff changeset	2456 static void index_invalidate_added(indexObject *self, Py_ssize_t start)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2457 {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2458 Py_ssize_t i, len = PyList_GET_SIZE(self->added);
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2459
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2460 for (i = start; i < len; i++) {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2461 PyObject *tuple = PyList_GET_ITEM(self->added, i);
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2462 PyObject *node = PyTuple_GET_ITEM(tuple, 7);
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2463
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	2464 nt_delete_node(&self->nt, PyBytes_AS_STRING(node));
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2465 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2466
16732 277e2acb7e5c parsers: use Py_CLEAR where appropriate Bryan O'Sullivan <bryano@fb.com> parents: 16699 diff changeset	2467 if (start == 0)
277e2acb7e5c parsers: use Py_CLEAR where appropriate Bryan O'Sullivan <bryano@fb.com> parents: 16699 diff changeset	2468 Py_CLEAR(self->added);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2469 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2470
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2471 /*
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2472 * Delete a numeric range of revs, which must be at the end of the
43582 ae5e39512ca0 revlog: delete references to deleted nullid sentinel value Martin von Zweigbergk <martinvonz@google.com> parents: 43554 diff changeset	2473 * range.
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2474 */
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2475 static int index_slice_del(indexObject self, PyObject item)
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2476 {
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2477 Py_ssize_t start, stop, step, slicelength;
38851 781b2720d2ac index: don't include nullid in len() Martin von Zweigbergk <martinvonz@google.com> parents: 38850 diff changeset	2478 Py_ssize_t length = index_length(self) + 1;
16784 12a852c7c763 parsers: reduce raw_length when truncating Bryan O'Sullivan <bryano@fb.com> parents: 16732 diff changeset	2479 int ret = 0;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2480
30171 7a3b59f0329a parsers: avoid PySliceObject cast on Python 3 Gregory Szorc <gregory.szorc@gmail.com> parents: 30169 diff changeset	2481 /* Argument changed from PySliceObject* to PyObject* in Python 3. */
7a3b59f0329a parsers: avoid PySliceObject cast on Python 3 Gregory Szorc <gregory.szorc@gmail.com> parents: 30169 diff changeset	2482 #ifdef IS_PY3K
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2483 if (PySlice_GetIndicesEx(item, length, &start, &stop, &step,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2484 &slicelength) < 0)
30171 7a3b59f0329a parsers: avoid PySliceObject cast on Python 3 Gregory Szorc <gregory.szorc@gmail.com> parents: 30169 diff changeset	2485 #else
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2486 if (PySlice_GetIndicesEx((PySliceObject *)item, length, &start, &stop,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2487 &step, &slicelength) < 0)
30171 7a3b59f0329a parsers: avoid PySliceObject cast on Python 3 Gregory Szorc <gregory.szorc@gmail.com> parents: 30169 diff changeset	2488 #endif
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2489 return -1;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2490
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2491 if (slicelength <= 0)
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2492 return 0;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2493
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2494 if ((step < 0 && start < stop) \|\| (step > 0 && start > stop))
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2495 stop = start;
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2496
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2497 if (step < 0) {
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2498 stop = start + 1;
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2499 start = stop + step * (slicelength - 1) - 1;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2500 step = -step;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2501 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2502
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2503 if (step != 1) {
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2504 PyErr_SetString(PyExc_ValueError,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2505 "revlog index delete requires step size of 1");
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2506 return -1;
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2507 }
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2508
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2509 if (stop != length - 1) {
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2510 PyErr_SetString(PyExc_IndexError,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2511 "revlog index deletion indices are invalid");
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2512 return -1;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2513 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2514
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	2515 if (start < self->length) {
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	2516 if (self->ntinitialized) {
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2517 Py_ssize_t i;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2518
43532 53581e220ba3 revlog: clean up the node of all revision stripped in the C code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42096 diff changeset	2519 for (i = start; i < self->length; i++) {
37999 514605777244 revlog: handle errors from index_node() in nt_insert() and index_slice_del() Martin von Zweigbergk <martinvonz@google.com> parents: 37978 diff changeset	2520 const char *node = index_node_existing(self, i);
514605777244 revlog: handle errors from index_node() in nt_insert() and index_slice_del() Martin von Zweigbergk <martinvonz@google.com> parents: 37978 diff changeset	2521 if (node == NULL)
514605777244 revlog: handle errors from index_node() in nt_insert() and index_slice_del() Martin von Zweigbergk <martinvonz@google.com> parents: 37978 diff changeset	2522 return -1;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2523
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	2524 nt_delete_node(&self->nt, node);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2525 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2526 if (self->added)
38942 3e74c01102af index: rename "nt_(indexObject self,...)" functions to "index_" Martin von Zweigbergk <martinvonz@google.com>* parents: 38941 diff changeset	2527 index_invalidate_added(self, 0);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2528 if (self->ntrev > start)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2529 self->ntrev = (int)start;
43847 49fa0b31ee1d cext-revlog: fixed __delitem__ for uninitialized nodetree Georges Racinet <georges.racinet@octobus.net> parents: 43582 diff changeset	2530 } else if (self->added) {
49fa0b31ee1d cext-revlog: fixed __delitem__ for uninitialized nodetree Georges Racinet <georges.racinet@octobus.net> parents: 43582 diff changeset	2531 Py_CLEAR(self->added);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2532 }
43847 49fa0b31ee1d cext-revlog: fixed __delitem__ for uninitialized nodetree Georges Racinet <georges.racinet@octobus.net> parents: 43582 diff changeset	2533
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	2534 self->length = start;
18504 d1d5fdcc2d46 parsers: fix memleak of revlog cache entries on strip Yuya Nishihara <yuya@tcha.org> parents: 18430 diff changeset	2535 if (start < self->raw_length) {
d1d5fdcc2d46 parsers: fix memleak of revlog cache entries on strip Yuya Nishihara <yuya@tcha.org> parents: 18430 diff changeset	2536 if (self->cache) {
d1d5fdcc2d46 parsers: fix memleak of revlog cache entries on strip Yuya Nishihara <yuya@tcha.org> parents: 18430 diff changeset	2537 Py_ssize_t i;
d1d5fdcc2d46 parsers: fix memleak of revlog cache entries on strip Yuya Nishihara <yuya@tcha.org> parents: 18430 diff changeset	2538 for (i = start; i < self->raw_length; i++)
d1d5fdcc2d46 parsers: fix memleak of revlog cache entries on strip Yuya Nishihara <yuya@tcha.org> parents: 18430 diff changeset	2539 Py_CLEAR(self->cache[i]);
d1d5fdcc2d46 parsers: fix memleak of revlog cache entries on strip Yuya Nishihara <yuya@tcha.org> parents: 18430 diff changeset	2540 }
16784 12a852c7c763 parsers: reduce raw_length when truncating Bryan O'Sullivan <bryano@fb.com> parents: 16732 diff changeset	2541 self->raw_length = start;
18504 d1d5fdcc2d46 parsers: fix memleak of revlog cache entries on strip Yuya Nishihara <yuya@tcha.org> parents: 18430 diff changeset	2542 }
16784 12a852c7c763 parsers: reduce raw_length when truncating Bryan O'Sullivan <bryano@fb.com> parents: 16732 diff changeset	2543 goto done;
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2544 }
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2545
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	2546 if (self->ntinitialized) {
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	2547 index_invalidate_added(self, start - self->length);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2548 if (self->ntrev > start)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2549 self->ntrev = (int)start;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2550 }
16784 12a852c7c763 parsers: reduce raw_length when truncating Bryan O'Sullivan <bryano@fb.com> parents: 16732 diff changeset	2551 if (self->added)
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	2552 ret = PyList_SetSlice(self->added, start - self->length,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2553 PyList_GET_SIZE(self->added), NULL);
16784 12a852c7c763 parsers: reduce raw_length when truncating Bryan O'Sullivan <bryano@fb.com> parents: 16732 diff changeset	2554 done:
16787 bda96ce993f9 parsers: cache the result of index_headrevs Bryan O'Sullivan <bryano@fb.com> parents: 16786 diff changeset	2555 Py_CLEAR(self->headrevs);
16784 12a852c7c763 parsers: reduce raw_length when truncating Bryan O'Sullivan <bryano@fb.com> parents: 16732 diff changeset	2556 return ret;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2557 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2558
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2559 /*
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2560 * Supported ops:
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2561 *
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2562 * slice deletion
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2563 * string assignment (extend node->rev mapping)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2564 * string deletion (shrink node->rev mapping)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2565 */
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2566 static int index_assign_subscript(indexObject self, PyObject item,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2567 PyObject *value)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2568 {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2569 char *node;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2570 long rev;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2571
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2572 if (PySlice_Check(item) && value == NULL)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2573 return index_slice_del(self, item);
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2574
38819 49628742d264 revlog: remove unnecessary output parameter from node_check() Martin von Zweigbergk <martinvonz@google.com> parents: 38305 diff changeset	2575 if (node_check(item, &node) == -1)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2576 return -1;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2577
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2578 if (value == NULL)
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2579 return self->ntinitialized ? nt_delete_node(&self->nt, node)
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2580 : 0;
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2581 rev = PyInt_AsLong(value);
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2582 if (rev > INT_MAX \|\| rev < 0) {
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2583 if (!PyErr_Occurred())
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2584 PyErr_SetString(PyExc_ValueError, "rev out of range");
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2585 return -1;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2586 }
23468 ee311681e591 parsers: ensure revlog index node tree is initialized before insertion Mike Edgar <adgar@google.com> parents: 23087 diff changeset	2587
38941 c0b6a7c78a21 index: split up nt_init() in two Martin von Zweigbergk <martinvonz@google.com> parents: 38940 diff changeset	2588 if (index_init_nt(self) == -1)
23468 ee311681e591 parsers: ensure revlog index node tree is initialized before insertion Mike Edgar <adgar@google.com> parents: 23087 diff changeset	2589 return -1;
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	2590 return nt_insert(&self->nt, node, (int)rev);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2591 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2592
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2593 /*
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2594 * Find all RevlogNG entries in an index that has inline data. Update
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2595 * the optional "offsets" table with those entries.
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2596 */
22401 9ba8a93e55f5 parsers: ensure correct return type for inline_scan Henrik Stuart <hg@hstuart.dk> parents: 22400 diff changeset	2597 static Py_ssize_t inline_scan(indexObject self, const char *offsets)
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2598 {
30577 6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2599 const char data = (const char )self->buf.buf;
20167 09e41ac6289d mpatch: rewrite pointer overflow checks Matt Mackall <mpm@selenic.com> parents: 20109 diff changeset	2600 Py_ssize_t pos = 0;
30577 6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2601 Py_ssize_t end = self->buf.len;
16863 bbedef66c6f3 parsers: replace magic number 64 with symbolic constant Bryan O'Sullivan <bryano@fb.com> parents: 16787 diff changeset	2602 long incr = v1_hdrsize;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2603 Py_ssize_t len = 0;
13254 5ef5eb1f3515 revlog: only build the nodemap on demand Matt Mackall <mpm@selenic.com> parents: 11361 diff changeset	2604
20167 09e41ac6289d mpatch: rewrite pointer overflow checks Matt Mackall <mpm@selenic.com> parents: 20109 diff changeset	2605 while (pos + v1_hdrsize <= end && pos >= 0) {
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2606 uint32_t comp_len;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2607 /* 3rd element of header is length of compressed inline data */
20167 09e41ac6289d mpatch: rewrite pointer overflow checks Matt Mackall <mpm@selenic.com> parents: 20109 diff changeset	2608 comp_len = getbe32(data + pos + 8);
16863 bbedef66c6f3 parsers: replace magic number 64 with symbolic constant Bryan O'Sullivan <bryano@fb.com> parents: 16787 diff changeset	2609 incr = v1_hdrsize + comp_len;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2610 if (offsets)
20167 09e41ac6289d mpatch: rewrite pointer overflow checks Matt Mackall <mpm@selenic.com> parents: 20109 diff changeset	2611 offsets[len] = data + pos;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2612 len++;
20167 09e41ac6289d mpatch: rewrite pointer overflow checks Matt Mackall <mpm@selenic.com> parents: 20109 diff changeset	2613 pos += incr;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2614 }
13254 5ef5eb1f3515 revlog: only build the nodemap on demand Matt Mackall <mpm@selenic.com> parents: 11361 diff changeset	2615
20167 09e41ac6289d mpatch: rewrite pointer overflow checks Matt Mackall <mpm@selenic.com> parents: 20109 diff changeset	2616 if (pos != end) {
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2617 if (!PyErr_Occurred())
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2618 PyErr_SetString(PyExc_ValueError, "corrupt index file");
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2619 return -1;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2620 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2621
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2622 return len;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2623 }
13254 5ef5eb1f3515 revlog: only build the nodemap on demand Matt Mackall <mpm@selenic.com> parents: 11361 diff changeset	2624
16572 8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2625 static int index_init(indexObject self, PyObject args)
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2626 {
16572 8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2627 PyObject data_obj, inlined_obj;
8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2628 Py_ssize_t size;
8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2629
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2630 /* Initialize before argument-checking to avoid index_dealloc() crash.
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2631 */
20109 e57c532c3835 parse_index2: fix crash on bad argument type (issue4110) Chris Jerdonek <chris.jerdonek@gmail.com> parents: 19728 diff changeset	2632 self->raw_length = 0;
e57c532c3835 parse_index2: fix crash on bad argument type (issue4110) Chris Jerdonek <chris.jerdonek@gmail.com> parents: 19728 diff changeset	2633 self->added = NULL;
e57c532c3835 parse_index2: fix crash on bad argument type (issue4110) Chris Jerdonek <chris.jerdonek@gmail.com> parents: 19728 diff changeset	2634 self->cache = NULL;
e57c532c3835 parse_index2: fix crash on bad argument type (issue4110) Chris Jerdonek <chris.jerdonek@gmail.com> parents: 19728 diff changeset	2635 self->data = NULL;
30577 6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2636 memset(&self->buf, 0, sizeof(self->buf));
20109 e57c532c3835 parse_index2: fix crash on bad argument type (issue4110) Chris Jerdonek <chris.jerdonek@gmail.com> parents: 19728 diff changeset	2637 self->headrevs = NULL;
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	2638 self->filteredrevs = Py_None;
2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	2639 Py_INCREF(Py_None);
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	2640 self->ntinitialized = 0;
20109 e57c532c3835 parse_index2: fix crash on bad argument type (issue4110) Chris Jerdonek <chris.jerdonek@gmail.com> parents: 19728 diff changeset	2641 self->offsets = NULL;
e57c532c3835 parse_index2: fix crash on bad argument type (issue4110) Chris Jerdonek <chris.jerdonek@gmail.com> parents: 19728 diff changeset	2642
16572 8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2643 if (!PyArg_ParseTuple(args, "OO", &data_obj, &inlined_obj))
8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2644 return -1;
30577 6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2645 if (!PyObject_CheckBuffer(data_obj)) {
6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2646 PyErr_SetString(PyExc_TypeError,
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2647 "data does not support buffer interface");
16572 8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2648 return -1;
8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2649 }
30577 6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2650
6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2651 if (PyObject_GetBuffer(data_obj, &self->buf, PyBUF_SIMPLE) == -1)
6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2652 return -1;
6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2653 size = self->buf.len;
16572 8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2654
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2655 self->inlined = inlined_obj && PyObject_IsTrue(inlined_obj);
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2656 self->data = data_obj;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2657
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2658 self->ntlookups = self->ntmisses = 0;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2659 self->ntrev = -1;
16597 b767382a8675 parsers: fix refcount bug on corrupt index Matt Mackall <mpm@selenic.com> parents: 16572 diff changeset	2660 Py_INCREF(self->data);
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2661
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2662 if (self->inlined) {
22401 9ba8a93e55f5 parsers: ensure correct return type for inline_scan Henrik Stuart <hg@hstuart.dk> parents: 22400 diff changeset	2663 Py_ssize_t len = inline_scan(self, NULL);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2664 if (len == -1)
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2665 goto bail;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2666 self->raw_length = len;
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	2667 self->length = len;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2668 } else {
16863 bbedef66c6f3 parsers: replace magic number 64 with symbolic constant Bryan O'Sullivan <bryano@fb.com> parents: 16787 diff changeset	2669 if (size % v1_hdrsize) {
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2670 PyErr_SetString(PyExc_ValueError, "corrupt index file");
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2671 goto bail;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2672 }
16863 bbedef66c6f3 parsers: replace magic number 64 with symbolic constant Bryan O'Sullivan <bryano@fb.com> parents: 16787 diff changeset	2673 self->raw_length = size / v1_hdrsize;
39068 52e9bf215f96 index: don't include nullid in the internal "length" field Martin von Zweigbergk <martinvonz@google.com> parents: 38944 diff changeset	2674 self->length = self->raw_length;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2675 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2676
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2677 return 0;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2678 bail:
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2679 return -1;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2680 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2681
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2682 static PyObject index_nodemap(indexObject self)
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2683 {
16572 8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2684 Py_INCREF(self);
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2685 return (PyObject *)self;
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2686 }
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2687
38944 c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2688 static void _index_clearcaches(indexObject *self)
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2689 {
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2690 if (self->cache) {
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2691 Py_ssize_t i;
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2692
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2693 for (i = 0; i < self->raw_length; i++)
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2694 Py_CLEAR(self->cache[i]);
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2695 free(self->cache);
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2696 self->cache = NULL;
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2697 }
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2698 if (self->offsets) {
39075 b935adb4b041 cext: fix a warning about differing const qualifiers on Windows Matt Harbison <matt_harbison@yahoo.com> parents: 39074 diff changeset	2699 PyMem_Free((void *)self->offsets);
38944 c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2700 self->offsets = NULL;
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2701 }
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	2702 if (self->ntinitialized) {
9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	2703 nt_dealloc(&self->nt);
38944 c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2704 }
39291 9f097214fbf3 index: embed nodetree in index object to avoid reference cycle Martin von Zweigbergk <martinvonz@google.com> parents: 39228 diff changeset	2705 self->ntinitialized = 0;
38944 c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2706 Py_CLEAR(self->headrevs);
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2707 }
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2708
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2709 static PyObject index_clearcaches(indexObject self)
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2710 {
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2711 _index_clearcaches(self);
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2712 self->ntrev = -1;
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2713 self->ntlookups = self->ntmisses = 0;
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2714 Py_RETURN_NONE;
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2715 }
c1de67691d5b index: move index_clearcaches() further down Martin von Zweigbergk <martinvonz@google.com> parents: 38943 diff changeset	2716
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2717 static void index_dealloc(indexObject *self)
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2718 {
16370 28bb4daf070c parsers: fix a memleak, and add a clearcaches method to the index Bryan O'Sullivan <bryano@fb.com> parents: 16363 diff changeset	2719 _index_clearcaches(self);
22484 2b5940f64750 obsolete: use C code for headrevs calculation Durham Goode <durham@fb.com> parents: 22403 diff changeset	2720 Py_XDECREF(self->filteredrevs);
30577 6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2721 if (self->buf.buf) {
6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2722 PyBuffer_Release(&self->buf);
6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2723 memset(&self->buf, 0, sizeof(self->buf));
6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2724 }
20109 e57c532c3835 parse_index2: fix crash on bad argument type (issue4110) Chris Jerdonek <chris.jerdonek@gmail.com> parents: 19728 diff changeset	2725 Py_XDECREF(self->data);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2726 Py_XDECREF(self->added);
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2727 PyObject_Del(self);
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2728 }
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2729
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2730 static PySequenceMethods index_sequence_methods = {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2731 (lenfunc)index_length, /* sq_length */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2732 0, /* sq_concat */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2733 0, /* sq_repeat */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2734 (ssizeargfunc)index_get, /* sq_item */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2735 0, /* sq_slice */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2736 0, /* sq_ass_item */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2737 0, /* sq_ass_slice */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2738 (objobjproc)index_contains, /* sq_contains */
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2739 };
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2740
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2741 static PyMappingMethods index_mapping_methods = {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2742 (lenfunc)index_length, /* mp_length */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2743 (binaryfunc)index_getitem, /* mp_subscript */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2744 (objobjargproc)index_assign_subscript, /* mp_ass_subscript */
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2745 };
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2746
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2747 static PyMethodDef index_methods[] = {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2748 {"ancestors", (PyCFunction)index_ancestors, METH_VARARGS,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2749 "return the gca set of the given revs"},
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2750 {"commonancestorsheads", (PyCFunction)index_commonancestorsheads,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2751 METH_VARARGS,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2752 "return the heads of the common ancestors of the given revs"},
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2753 {"clearcaches", (PyCFunction)index_clearcaches, METH_NOARGS,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2754 "clear the index caches"},
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2755 {"get", (PyCFunction)index_m_get, METH_VARARGS, "get an index entry"},
43554 b56de57c45ce index: add a `get_rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43552 diff changeset	2756 {"get_rev", (PyCFunction)index_m_get, METH_VARARGS,
b56de57c45ce index: add a `get_rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43552 diff changeset	2757 "return `rev` associated with a node or None"},
43534 0c659fc20207 index: add a `has_node` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43532 diff changeset	2758 {"has_node", (PyCFunction)index_m_has_node, METH_O,
0c659fc20207 index: add a `has_node` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43532 diff changeset	2759 "return True if the node exist in the index"},
43552 bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2760 {"rev", (PyCFunction)index_m_rev, METH_O,
bd87114ce341 index: add a `rev` method (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43534 diff changeset	2761 "return `rev` associated with a node or raise RevlogError"},
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2762 {"computephasesmapsets", (PyCFunction)compute_phases_map_sets, METH_VARARGS,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2763 "compute phases"},
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2764 {"reachableroots2", (PyCFunction)reachableroots2, METH_VARARGS,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2765 "reachableroots"},
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2766 {"headrevs", (PyCFunction)index_headrevs, METH_VARARGS,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2767 "get head revisions"}, /* Can do filtering since 3.2 */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2768 {"headrevsfiltered", (PyCFunction)index_headrevs, METH_VARARGS,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2769 "get filtered head revisions"}, /* Can always do filtering */
41086 a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	2770 {"issnapshot", (PyCFunction)index_issnapshot, METH_O,
a28833d79aca revlog: use the native implementation of issnapshot Boris Feld <boris.feld@octobus.net> parents: 41085 diff changeset	2771 "True if the object is a snapshot"},
41108 38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	2772 {"findsnapshots", (PyCFunction)index_findsnapshots, METH_VARARGS,
38e88450138c delta: have a native implementation of _findsnapshot Boris Feld <boris.feld@octobus.net> parents: 41086 diff changeset	2773 "Gather snapshot data in a cache dict"},
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2774 {"deltachain", (PyCFunction)index_deltachain, METH_VARARGS,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2775 "determine revisions with deltas to reconstruct fulltext"},
40707 cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	2776 {"slicechunktodensity", (PyCFunction)index_slicechunktodensity,
cc76ca9fca20 sparse-revlog: introduce native (C) implementation of slicechunktodensity Boris Feld <boris.feld@octobus.net> parents: 40706 diff changeset	2777 METH_VARARGS, "determine revisions with deltas to reconstruct fulltext"},
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2778 {"append", (PyCFunction)index_append, METH_O, "append an index entry"},
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2779 {"partialmatch", (PyCFunction)index_partialmatch, METH_VARARGS,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2780 "match a potentially ambiguous node ID"},
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2781 {"shortest", (PyCFunction)index_shortest, METH_VARARGS,
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2782 "find length of shortest hex nodeid of a binary ID"},
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2783 {"stats", (PyCFunction)index_stats, METH_NOARGS, "stats for the index"},
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2784 {NULL} /* Sentinel */
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2785 };
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2786
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2787 static PyGetSetDef index_getset[] = {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2788 {"nodemap", (getter)index_nodemap, NULL, "nodemap", NULL},
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2789 {NULL} /* Sentinel */
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2790 };
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2791
40860 18a8def6e1b5 revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol Yuya Nishihara <yuya@tcha.org> parents: 40859 diff changeset	2792 PyTypeObject HgRevlogIndex_Type = {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2793 PyVarObject_HEAD_INIT(NULL, 0) /* header */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2794 "parsers.index", /* tp_name */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2795 sizeof(indexObject), /* tp_basicsize */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2796 0, /* tp_itemsize */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2797 (destructor)index_dealloc, /* tp_dealloc */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2798 0, /* tp_print */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2799 0, /* tp_getattr */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2800 0, /* tp_setattr */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2801 0, /* tp_compare */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2802 0, /* tp_repr */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2803 0, /* tp_as_number */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2804 &index_sequence_methods, /* tp_as_sequence */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2805 &index_mapping_methods, /* tp_as_mapping */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2806 0, /* tp_hash */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2807 0, /* tp_call */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2808 0, /* tp_str */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2809 0, /* tp_getattro */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2810 0, /* tp_setattro */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2811 0, /* tp_as_buffer */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2812 Py_TPFLAGS_DEFAULT, /* tp_flags */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2813 "revlog index", /* tp_doc */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2814 0, /* tp_traverse */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2815 0, /* tp_clear */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2816 0, /* tp_richcompare */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2817 0, /* tp_weaklistoffset */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2818 0, /* tp_iter */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2819 0, /* tp_iternext */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2820 index_methods, /* tp_methods */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2821 0, /* tp_members */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2822 index_getset, /* tp_getset */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2823 0, /* tp_base */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2824 0, /* tp_dict */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2825 0, /* tp_descr_get */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2826 0, /* tp_descr_set */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2827 0, /* tp_dictoffset */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2828 (initproc)index_init, /* tp_init */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2829 0, /* tp_alloc */
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2830 };
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2831
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2832 /*
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2833 * returns a tuple of the form (index, index, cache) with elements as
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2834 * follows:
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2835 *
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16393 diff changeset	2836 * index: an index object that lazily parses RevlogNG records
30577 6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2837 * cache: if data is inlined, a tuple (0, index_file_content), else None
6146d5acee69 parsers: use buffer to store revlog index Jun Wu <quark@fb.com> parents: 30171 diff changeset	2838 * index_file_content could be a string, or a buffer
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2839 *
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2840 * added complications are for backwards compatibility
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2841 */
32378 7d0c69505a66 cext: extract revlog/index parsing code to own C file Gregory Szorc <gregory.szorc@gmail.com> parents: 32372 diff changeset	2842 PyObject parse_index2(PyObject self, PyObject *args)
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2843 {
16572 8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2844 PyObject tuple = NULL, cache = NULL;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2845 indexObject *idx;
16572 8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2846 int ret;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2847
40860 18a8def6e1b5 revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol Yuya Nishihara <yuya@tcha.org> parents: 40859 diff changeset	2848 idx = PyObject_New(indexObject, &HgRevlogIndex_Type);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2849 if (idx == NULL)
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2850 goto bail;
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2851
16572 8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2852 ret = index_init(idx, args);
8d44b5a2974f parsers: fix refcount leak, simplify init of index (issue3417) Bryan O'Sullivan <bryano@fb.com> parents: 16437 diff changeset	2853 if (ret == -1)
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2854 goto bail;
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2855
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2856 if (idx->inlined) {
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2857 cache = Py_BuildValue("iO", 0, idx->data);
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2858 if (cache == NULL)
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2859 goto bail;
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2860 } else {
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2861 cache = Py_None;
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2862 Py_INCREF(cache);
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2863 }
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2864
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2865 tuple = Py_BuildValue("NN", idx, cache);
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2866 if (!tuple)
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2867 goto bail;
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2868 return tuple;
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2869
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2870 bail:
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2871 Py_XDECREF(idx);
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2872 Py_XDECREF(cache);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	2873 Py_XDECREF(tuple);
7108 1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2874 return NULL;
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2875 }
1ca878d7b849 C implementation of revlog index parsing Bernhard Leiner <bleiner@gmail.com> parents: 7093 diff changeset	2876
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2877 #ifdef WITH_RUST
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2878
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2879 /* rustlazyancestors: iteration over ancestors implemented in Rust
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2880 *
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2881 * This class holds a reference to an index and to the Rust iterator.
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2882 */
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2883 typedef struct rustlazyancestorsObjectStruct rustlazyancestorsObject;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2884
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2885 struct rustlazyancestorsObjectStruct {
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2886 PyObject_HEAD
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2887 /* Type-specific fields go here. */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2888 indexObject index; / Ref kept to avoid GC'ing the index */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2889 void iter; / Rust iterator */
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2890 };
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2891
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2892 /* FFI exposed from Rust code */
40862 54a60968f0aa rust: look up HgRevlogIndex_GetParents() from symbol table Yuya Nishihara <yuya@tcha.org> parents: 40861 diff changeset	2893 rustlazyancestorsObject rustlazyancestors_init(indexObject index,
54a60968f0aa rust: look up HgRevlogIndex_GetParents() from symbol table Yuya Nishihara <yuya@tcha.org> parents: 40861 diff changeset	2894 /* intrevs vector */
54a60968f0aa rust: look up HgRevlogIndex_GetParents() from symbol table Yuya Nishihara <yuya@tcha.org> parents: 40861 diff changeset	2895 Py_ssize_t initrevslen,
54a60968f0aa rust: look up HgRevlogIndex_GetParents() from symbol table Yuya Nishihara <yuya@tcha.org> parents: 40861 diff changeset	2896 long *initrevs, long stoprev,
54a60968f0aa rust: look up HgRevlogIndex_GetParents() from symbol table Yuya Nishihara <yuya@tcha.org> parents: 40861 diff changeset	2897 int inclusive);
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2898 void rustlazyancestors_drop(rustlazyancestorsObject *self);
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2899 int rustlazyancestors_next(rustlazyancestorsObject *self);
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40273 diff changeset	2900 int rustlazyancestors_contains(rustlazyancestorsObject *self, long rev);
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2901
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2902 /* CPython instance methods */
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2903 static int rustla_init(rustlazyancestorsObject self, PyObject args)
40813 884321cd26c3 rust: fix possible out-of-bounds read through index_get_parents() Yuya Nishihara <yuya@tcha.org> parents: 40812 diff changeset	2904 {
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2905 PyObject *initrevsarg = NULL;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2906 PyObject *inclusivearg = NULL;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2907 long stoprev = 0;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2908 long *initrevs = NULL;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2909 int inclusive = 0;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2910 Py_ssize_t i;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2911
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2912 indexObject *index;
40860 18a8def6e1b5 revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol Yuya Nishihara <yuya@tcha.org> parents: 40859 diff changeset	2913 if (!PyArg_ParseTuple(args, "O!O!lO!", &HgRevlogIndex_Type, &index,
18a8def6e1b5 revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol Yuya Nishihara <yuya@tcha.org> parents: 40859 diff changeset	2914 &PyList_Type, &initrevsarg, &stoprev,
18a8def6e1b5 revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol Yuya Nishihara <yuya@tcha.org> parents: 40859 diff changeset	2915 &PyBool_Type, &inclusivearg))
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2916 return -1;
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2917
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2918 Py_INCREF(index);
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2919 self->index = index;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2920
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2921 if (inclusivearg == Py_True)
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2922 inclusive = 1;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2923
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2924 Py_ssize_t linit = PyList_GET_SIZE(initrevsarg);
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2925
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2926 initrevs = (long *)calloc(linit, sizeof(long));
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2927
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2928 if (initrevs == NULL) {
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2929 PyErr_NoMemory();
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2930 goto bail;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2931 }
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2932
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2933 for (i = 0; i < linit; i++) {
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2934 initrevs[i] = PyInt_AsLong(PyList_GET_ITEM(initrevsarg, i));
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2935 }
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2936 if (PyErr_Occurred())
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2937 goto bail;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2938
40862 54a60968f0aa rust: look up HgRevlogIndex_GetParents() from symbol table Yuya Nishihara <yuya@tcha.org> parents: 40861 diff changeset	2939 self->iter =
54a60968f0aa rust: look up HgRevlogIndex_GetParents() from symbol table Yuya Nishihara <yuya@tcha.org> parents: 40861 diff changeset	2940 rustlazyancestors_init(index, linit, initrevs, stoprev, inclusive);
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2941 if (self->iter == NULL) {
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2942 /* if this is because of GraphError::ParentOutOfRange
40862 54a60968f0aa rust: look up HgRevlogIndex_GetParents() from symbol table Yuya Nishihara <yuya@tcha.org> parents: 40861 diff changeset	2943 * HgRevlogIndex_GetParents() has already set the proper
54a60968f0aa rust: look up HgRevlogIndex_GetParents() from symbol table Yuya Nishihara <yuya@tcha.org> parents: 40861 diff changeset	2944 * exception */
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2945 goto bail;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2946 }
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2947
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2948 free(initrevs);
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2949 return 0;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2950
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2951 bail:
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2952 free(initrevs);
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2953 return -1;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2954 };
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2955
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2956 static void rustla_dealloc(rustlazyancestorsObject *self)
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2957 {
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2958 Py_XDECREF(self->index);
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2959 if (self->iter != NULL) { /* can happen if rustla_init failed */
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2960 rustlazyancestors_drop(self->iter);
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2961 }
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2962 PyObject_Del(self);
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2963 }
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2964
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2965 static PyObject rustla_next(rustlazyancestorsObject self)
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2966 {
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2967 int res = rustlazyancestors_next(self->iter);
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2968 if (res == -1) {
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2969 /* Setting an explicit exception seems unnecessary
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2970 * as examples from Python source code (Objects/rangeobjets.c
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2971 * and Modules/_io/stringio.c) seem to demonstrate.
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2972 */
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2973 return NULL;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2974 }
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2975 return PyInt_FromLong(res);
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2976 }
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2977
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2978 static int rustla_contains(rustlazyancestorsObject self, PyObject rev)
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2979 {
40598 fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	2980 long lrev;
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	2981 if (!pylong_to_long(rev, &lrev)) {
fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	2982 PyErr_Clear();
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40273 diff changeset	2983 return 0;
72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40273 diff changeset	2984 }
40598 fa33196088c4 revlog: replace PyInt_AS_LONG with a more portable helper function Augie Fackler <augie@google.com> parents: 40562 diff changeset	2985 return rustlazyancestors_contains(self->iter, lrev);
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40273 diff changeset	2986 }
72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40273 diff changeset	2987
72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40273 diff changeset	2988 static PySequenceMethods rustla_sequence_methods = {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2989 0, /* sq_length */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2990 0, /* sq_concat */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2991 0, /* sq_repeat */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2992 0, /* sq_item */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2993 0, /* sq_slice */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2994 0, /* sq_ass_item */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2995 0, /* sq_ass_slice */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	2996 (objobjproc)rustla_contains, /* sq_contains */
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40273 diff changeset	2997 };
72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40273 diff changeset	2998
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	2999 static PyTypeObject rustlazyancestorsType = {
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3000 PyVarObject_HEAD_INIT(NULL, 0) /* header */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3001 "parsers.rustlazyancestors", /* tp_name */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3002 sizeof(rustlazyancestorsObject), /* tp_basicsize */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3003 0, /* tp_itemsize */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3004 (destructor)rustla_dealloc, /* tp_dealloc */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3005 0, /* tp_print */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3006 0, /* tp_getattr */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3007 0, /* tp_setattr */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3008 0, /* tp_compare */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3009 0, /* tp_repr */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3010 0, /* tp_as_number */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3011 &rustla_sequence_methods, /* tp_as_sequence */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3012 0, /* tp_as_mapping */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3013 0, /* tp_hash */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3014 0, /* tp_call */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3015 0, /* tp_str */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3016 0, /* tp_getattro */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3017 0, /* tp_setattro */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3018 0, /* tp_as_buffer */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3019 Py_TPFLAGS_DEFAULT, /* tp_flags */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3020 "Iterator over ancestors, implemented in Rust", /* tp_doc */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3021 0, /* tp_traverse */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3022 0, /* tp_clear */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3023 0, /* tp_richcompare */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3024 0, /* tp_weaklistoffset */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3025 0, /* tp_iter */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3026 (iternextfunc)rustla_next, /* tp_iternext */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3027 0, /* tp_methods */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3028 0, /* tp_members */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3029 0, /* tp_getset */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3030 0, /* tp_base */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3031 0, /* tp_dict */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3032 0, /* tp_descr_get */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3033 0, /* tp_descr_set */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3034 0, /* tp_dictoffset */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3035 (initproc)rustla_init, /* tp_init */
e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3036 0, /* tp_alloc */
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	3037 };
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	3038 #endif /* WITH_RUST */
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	3039
43959 f384d68d8ea8 revlog: made C Capsule an array of function pointers Georges Racinet <georges.racinet@octobus.net> parents: 43847 diff changeset	3040 static Revlog_CAPI CAPI = {
44066 f5d2720f3bea revlog-native: introduced ABI version in capsule Georges Racinet <georges.racinet@octobus.net> parents: 43959 diff changeset	3041 /* increment the abi_version field upon each change in the Revlog_CAPI
f5d2720f3bea revlog-native: introduced ABI version in capsule Georges Racinet <georges.racinet@octobus.net> parents: 43959 diff changeset	3042 struct or in the ABI of the listed functions */
f5d2720f3bea revlog-native: introduced ABI version in capsule Georges Racinet <georges.racinet@octobus.net> parents: 43959 diff changeset	3043 1,
43959 f384d68d8ea8 revlog: made C Capsule an array of function pointers Georges Racinet <georges.racinet@octobus.net> parents: 43847 diff changeset	3044 HgRevlogIndex_GetParents,
f384d68d8ea8 revlog: made C Capsule an array of function pointers Georges Racinet <georges.racinet@octobus.net> parents: 43847 diff changeset	3045 };
f384d68d8ea8 revlog: made C Capsule an array of function pointers Georges Racinet <georges.racinet@octobus.net> parents: 43847 diff changeset	3046
32378 7d0c69505a66 cext: extract revlog/index parsing code to own C file Gregory Szorc <gregory.szorc@gmail.com> parents: 32372 diff changeset	3047 void revlog_module_init(PyObject *mod)
24017 72c9b5ae7278 parsers: add fm1readmarker Augie Fackler <augie@google.com> parents: 24004 diff changeset	3048 {
41052 4c25038c112c rust-cpython: implement Graph using C parents function Georges Racinet <gracinet@anybox.fr> parents: 40963 diff changeset	3049 PyObject *caps = NULL;
40860 18a8def6e1b5 revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol Yuya Nishihara <yuya@tcha.org> parents: 40859 diff changeset	3050 HgRevlogIndex_Type.tp_new = PyType_GenericNew;
18a8def6e1b5 revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol Yuya Nishihara <yuya@tcha.org> parents: 40859 diff changeset	3051 if (PyType_Ready(&HgRevlogIndex_Type) < 0)
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	3052 return;
40860 18a8def6e1b5 revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol Yuya Nishihara <yuya@tcha.org> parents: 40859 diff changeset	3053 Py_INCREF(&HgRevlogIndex_Type);
18a8def6e1b5 revlog: rename indexType to HgRevlogIndex_Type as it's a global symbol Yuya Nishihara <yuya@tcha.org> parents: 40859 diff changeset	3054 PyModule_AddObject(mod, "index", (PyObject *)&HgRevlogIndex_Type);
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	3055
39218 b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	3056 nodetreeType.tp_new = PyType_GenericNew;
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	3057 if (PyType_Ready(&nodetreeType) < 0)
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	3058 return;
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	3059 Py_INCREF(&nodetreeType);
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	3060 PyModule_AddObject(mod, "nodetree", (PyObject *)&nodetreeType);
b85b377e7fc2 index: make node tree a Python object Martin von Zweigbergk <martinvonz@google.com> parents: 39075 diff changeset	3061
40088 129bfc7ad2cc revlog: if the module is initialized more than once, don't leak nullentry Augie Fackler <augie@google.com> parents: 39609 diff changeset	3062 if (!nullentry) {
42096 509a0477b3a6 cext: cast s# arguments of Py_BuildValue() to Py_ssize_t Yuya Nishihara <yuya@tcha.org> parents: 42067 diff changeset	3063 nullentry =
509a0477b3a6 cext: cast s# arguments of Py_BuildValue() to Py_ssize_t Yuya Nishihara <yuya@tcha.org> parents: 42067 diff changeset	3064 Py_BuildValue(PY23("iiiiiiis#", "iiiiiiiy#"), 0, 0, 0, -1,
509a0477b3a6 cext: cast s# arguments of Py_BuildValue() to Py_ssize_t Yuya Nishihara <yuya@tcha.org> parents: 42067 diff changeset	3065 -1, -1, -1, nullid, (Py_ssize_t)20);
40088 129bfc7ad2cc revlog: if the module is initialized more than once, don't leak nullentry Augie Fackler <augie@google.com> parents: 39609 diff changeset	3066 }
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	3067 if (nullentry)
2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	3068 PyObject_GC_UnTrack(nullentry);
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	3069
43959 f384d68d8ea8 revlog: made C Capsule an array of function pointers Georges Racinet <georges.racinet@octobus.net> parents: 43847 diff changeset	3070 caps = PyCapsule_New(&CAPI, "mercurial.cext.parsers.revlog_CAPI", NULL);
41052 4c25038c112c rust-cpython: implement Graph using C parents function Georges Racinet <gracinet@anybox.fr> parents: 40963 diff changeset	3071 if (caps != NULL)
43959 f384d68d8ea8 revlog: made C Capsule an array of function pointers Georges Racinet <georges.racinet@octobus.net> parents: 43847 diff changeset	3072 PyModule_AddObject(mod, "revlog_CAPI", caps);
41052 4c25038c112c rust-cpython: implement Graph using C parents function Georges Racinet <gracinet@anybox.fr> parents: 40963 diff changeset	3073
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	3074 #ifdef WITH_RUST
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	3075 rustlazyancestorsType.tp_new = PyType_GenericNew;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	3076 if (PyType_Ready(&rustlazyancestorsType) < 0)
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	3077 return;
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	3078 Py_INCREF(&rustlazyancestorsType);
3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	3079 PyModule_AddObject(mod, "rustlazyancestors",
40562 e5ad3ef90aa1 revlog: give formatting to clang-format Augie Fackler <augie@google.com> parents: 40561 diff changeset	3080 (PyObject *)&rustlazyancestorsType);
40273 3b275f549777 rust: exposing in parsers module Georges Racinet <gracinet@anybox.fr> parents: 40099 diff changeset	3081 #endif
16363 2cdd7e63211b parsers: incrementally parse the revlog index in C Bryan O'Sullivan <bryano@fb.com> parents: 15033 diff changeset	3082 }

Mercurial > public > mercurial-scm > hg

annotate mercurial/cext/revlog.c @ 44066:f5d2720f3bea