/*

 parsers.c - efficient content parsing

 Copyright 2008 Matt Mackall <mpm@selenic.com> and others

 This software may be used and distributed according to the terms of

 the GNU General Public License, incorporated herein by reference.

*/

#include <Python.h>

#include <assert.h>

#include <ctype.h>

#include <limits.h>

#include <stddef.h>

#include <string.h>

#include "bitmanipulation.h"

#include "charencode.h"

#include "util.h"

#ifdef IS_PY3K

/* The mapping of Python types is meant to be temporary to get Python

 * 3 to compile. We should remove this once Python 3 support is fully

 * supported and proper types are used in the extensions themselves. */

#define PyInt_Check PyLong_Check

#define PyInt_FromLong PyLong_FromLong

#define PyInt_FromSsize_t PyLong_FromSsize_t

#define PyInt_AsLong PyLong_AsLong

#endif

typedef struct indexObjectStruct indexObject;

typedef struct {

	int children[16];

} nodetreenode;

/*

 * A base-16 trie for fast node->rev mapping.

 *

 * Positive value is index of the next node in the trie

 * Negative value is a leaf: -(rev + 2)

 * Zero is empty

 */

typedef struct {

	indexObject *index;

	nodetreenode *nodes;

	unsigned length;   /* # nodes in use */

	unsigned capacity; /* # nodes allocated */

	int depth;         /* maximum depth of tree */

	int splits;        /* # splits performed */

} nodetree;

typedef struct {

	PyObject_HEAD /* ; */

	    nodetree nt;

} nodetreeObject;

/*

 * This class has two behaviors.

 *

 * When used in a list-like way (with integer keys), we decode an

 * entry in a RevlogNG index file on demand. Our last entry is a

 * sentinel, always a nullid.  We have limited support for

 * integer-keyed insert and delete, only at elements right before the

 * sentinel.

 *

 * With string keys, we lazily perform a reverse mapping from node to

 * rev, using a base-16 trie.

 */

struct indexObjectStruct {

	PyObject_HEAD

	    /* Type-specific fields go here. */

	    PyObject *data;     /* raw bytes of index */

	Py_buffer buf;          /* buffer of data */

	PyObject **cache;       /* cached tuples */

	const char **offsets;   /* populated on demand */

	Py_ssize_t raw_length;  /* original number of elements */

	Py_ssize_t length;      /* current number of elements */

	PyObject *added;        /* populated on demand */

	PyObject *headrevs;     /* cache, invalidated on changes */

	PyObject *filteredrevs; /* filtered revs set */

	nodetree nt;            /* base-16 trie */

	int ntinitialized;      /* 0 or 1 */

	int ntrev;              /* last rev scanned */

	int ntlookups;          /* # lookups */

	int ntmisses;           /* # lookups that miss the cache */

	int inlined;

};

static Py_ssize_t index_length(const indexObject *self)

{

	if (self->added == NULL)

		return self->length;

	return self->length + PyList_GET_SIZE(self->added);

}

static PyObject *nullentry = NULL;

static const char nullid[20] = {0};

static Py_ssize_t inline_scan(indexObject *self, const char **offsets);

#if LONG_MAX == 0x7fffffffL

static const char *const tuple_format = PY23("Kiiiiiis#", "Kiiiiiiy#");

#else

static const char *const tuple_format = PY23("kiiiiiis#", "kiiiiiiy#");

#endif

/* A RevlogNG v1 index entry is 64 bytes long. */

static const long v1_hdrsize = 64;

static void raise_revlog_error(void)

{

	PyObject *mod = NULL, *dict = NULL, *errclass = NULL;

	mod = PyImport_ImportModule("mercurial.error");

	if (mod == NULL) {

		goto cleanup;

	}

	dict = PyModule_GetDict(mod);

	if (dict == NULL) {

		goto cleanup;

	}

	Py_INCREF(dict);

	errclass = PyDict_GetItemString(dict, "RevlogError");

	if (errclass == NULL) {

		PyErr_SetString(PyExc_SystemError,

		                "could not find RevlogError");

		goto cleanup;

	}

	/* value of exception is ignored by callers */

	PyErr_SetString(errclass, "RevlogError");

cleanup:

	Py_XDECREF(dict);

	Py_XDECREF(mod);

}

/*

 * Return a pointer to the beginning of a RevlogNG record.

 */

static const char *index_deref(indexObject *self, Py_ssize_t pos)

{

	if (self->inlined && pos > 0) {

		if (self->offsets == NULL) {

			self->offsets = PyMem_Malloc(self->raw_length *

			                             sizeof(*self->offsets));

			if (self->offsets == NULL)

				return (const char *)PyErr_NoMemory();

			inline_scan(self, self->offsets);

		}

		return self->offsets[pos];

	}

	return (const char *)(self->buf.buf) + pos * v1_hdrsize;

}

static inline int index_get_parents(indexObject *self, Py_ssize_t rev, int *ps,

                                    int maxrev)

{

	if (rev >= self->length) {

		long tmp;

		PyObject *tuple =

		    PyList_GET_ITEM(self->added, rev - self->length);

		if (!pylong_to_long(PyTuple_GET_ITEM(tuple, 5), &tmp)) {

			return -1;

		}

		ps[0] = (int)tmp;

		if (!pylong_to_long(PyTuple_GET_ITEM(tuple, 6), &tmp)) {

			return -1;

		}

		ps[1] = (int)tmp;

	} else {

		const char *data = index_deref(self, rev);

		ps[0] = getbe32(data + 24);

		ps[1] = getbe32(data + 28);

	}

	/* If index file is corrupted, ps[] may point to invalid revisions. So

	 * there is a risk of buffer overflow to trust them unconditionally. */

	if (ps[0] > maxrev || ps[1] > maxrev) {

		PyErr_SetString(PyExc_ValueError, "parent out of range");

		return -1;

	}

	return 0;

}

static inline int64_t index_get_start(indexObject *self, Py_ssize_t rev)

{

	uint64_t offset;

	if (rev >= self->length) {

		PyObject *tuple;

		PyObject *pylong;

		PY_LONG_LONG tmp;

		tuple = PyList_GET_ITEM(self->added, rev - self->length);

		pylong = PyTuple_GET_ITEM(tuple, 0);

		tmp = PyLong_AsLongLong(pylong);

		if (tmp == -1 && PyErr_Occurred()) {

			return -1;

		}

		if (tmp < 0) {

			PyErr_Format(PyExc_OverflowError,

			             "revlog entry size out of bound (%lld)",

			             (long long)tmp);

			return -1;

		}

		offset = (uint64_t)tmp;

	} else {

		const char *data = index_deref(self, rev);

		offset = getbe32(data + 4);

		if (rev == 0) {

			/* mask out version number for the first entry */

			offset &= 0xFFFF;

		} else {

			uint32_t offset_high = getbe32(data);

			offset |= ((uint64_t)offset_high) << 32;

		}

	}

	return (int64_t)(offset >> 16);

}

static inline int index_get_length(indexObject *self, Py_ssize_t rev)

{

	if (rev >= self->length) {

		PyObject *tuple;

		PyObject *pylong;

		long ret;

		tuple = PyList_GET_ITEM(self->added, rev - self->length);

		pylong = PyTuple_GET_ITEM(tuple, 1);

		ret = PyInt_AsLong(pylong);

		if (ret == -1 && PyErr_Occurred()) {

			return -1;

		}

		if (ret < 0 || ret > (long)INT_MAX) {

			PyErr_Format(PyExc_OverflowError,

			             "revlog entry size out of bound (%ld)",

			             ret);

			return -1;

		}

		return (int)ret;

	} else {

		const char *data = index_deref(self, rev);

		return (int)getbe32(data + 8);

	}

}

/*

 * RevlogNG format (all in big endian, data may be inlined):

 *    6 bytes: offset

 *    2 bytes: flags

 *    4 bytes: compressed length

 *    4 bytes: uncompressed length

 *    4 bytes: base revision

 *    4 bytes: link revision

 *    4 bytes: parent 1 revision

 *    4 bytes: parent 2 revision

 *   32 bytes: nodeid (only 20 bytes used)

 */

static PyObject *index_get(indexObject *self, Py_ssize_t pos)

{

	uint64_t offset_flags;

	int comp_len, uncomp_len, base_rev, link_rev, parent_1, parent_2;

	const char *c_node_id;

	const char *data;

	Py_ssize_t length = index_length(self);

	PyObject *entry;

	if (pos == -1) {

		Py_INCREF(nullentry);

		return nullentry;

	}

	if (pos < 0 || pos >= length) {

		PyErr_SetString(PyExc_IndexError, "revlog index out of range");

		return NULL;

	}

	if (pos >= self->length) {

		PyObject *obj;

		obj = PyList_GET_ITEM(self->added, pos - self->length);

		Py_INCREF(obj);

		return obj;

	}

	if (self->cache) {

		if (self->cache[pos]) {

			Py_INCREF(self->cache[pos]);

			return self->cache[pos];

		}

	} else {

		self->cache = calloc(self->raw_length, sizeof(PyObject *));

		if (self->cache == NULL)

			return PyErr_NoMemory();

	}

	data = index_deref(self, pos);

	if (data == NULL)

		return NULL;

	offset_flags = getbe32(data + 4);

	if (pos == 0) /* mask out version number for the first entry */

		offset_flags &= 0xFFFF;

	else {

		uint32_t offset_high = getbe32(data);

		offset_flags |= ((uint64_t)offset_high) << 32;

	}

	comp_len = getbe32(data + 8);

	uncomp_len = getbe32(data + 12);

	base_rev = getbe32(data + 16);

	link_rev = getbe32(data + 20);

	parent_1 = getbe32(data + 24);

	parent_2 = getbe32(data + 28);

	c_node_id = data + 32;

	entry = Py_BuildValue(tuple_format, offset_flags, comp_len, uncomp_len,

	                      base_rev, link_rev, parent_1, parent_2, c_node_id,

	                      20);

	if (entry) {

		PyObject_GC_UnTrack(entry);

		Py_INCREF(entry);

	}

	self->cache[pos] = entry;

	return entry;

}

/*

 * Return the 20-byte SHA of the node corresponding to the given rev.

 */

static const char *index_node(indexObject *self, Py_ssize_t pos)

{

	Py_ssize_t length = index_length(self);

	const char *data;

	if (pos == -1)

		return nullid;

	if (pos >= length)

		return NULL;

	if (pos >= self->length) {

		PyObject *tuple, *str;

		tuple = PyList_GET_ITEM(self->added, pos - self->length);

		str = PyTuple_GetItem(tuple, 7);

		return str ? PyBytes_AS_STRING(str) : NULL;

	}

	data = index_deref(self, pos);

	return data ? data + 32 : NULL;

}

/*

 * Return the 20-byte SHA of the node corresponding to the given rev. The

 * rev is assumed to be existing. If not, an exception is set.

 */

static const char *index_node_existing(indexObject *self, Py_ssize_t pos)

{

	const char *node = index_node(self, pos);

	if (node == NULL) {

		PyErr_Format(PyExc_IndexError, "could not access rev %d",

		             (int)pos);

	}

	return node;

}

static int nt_insert(nodetree *self, const char *node, int rev);

static int node_check(PyObject *obj, char **node)

{

	Py_ssize_t nodelen;

	if (PyBytes_AsStringAndSize(obj, node, &nodelen) == -1)

		return -1;

	if (nodelen == 20)

		return 0;

	PyErr_SetString(PyExc_ValueError, "20-byte hash required");

	return -1;

}

static PyObject *index_append(indexObject *self, PyObject *obj)

{

	char *node;

	Py_ssize_t len;

	if (!PyTuple_Check(obj) || PyTuple_GET_SIZE(obj) != 8) {