/*

 parsers.c - efficient content parsing

 Copyright 2008 Olivia Mackall <olivia@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.

*/

#define PY_SSIZE_T_CLEAN

#include <Python.h>

#include <assert.h>

#include <ctype.h>

#include <limits.h>

#include <stddef.h>

#include <stdlib.h>

#include <string.h>

#include <structmember.h>

#include "bitmanipulation.h"

#include "charencode.h"

#include "compat.h"

#include "revlog.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;

typedef struct {

	int abi_version;

	Py_ssize_t (*index_length)(const indexObject *);

	const char *(*index_node)(indexObject *, Py_ssize_t);

	int (*index_parents)(PyObject *, int, int *);

} Revlog_CAPI;

/*

 * 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;

	Py_ssize_t nodelen;

	size_t length;   /* # nodes in use */

	size_t 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. We have limited support for

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

 * end.

 *

 * 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_ssize_t nodelen;     /* digest size of the hash, 20 for SHA-1 */

	PyObject *nullentry;    /* fast path for references to null */

	Py_buffer buf;          /* buffer of data */

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

	Py_ssize_t length;      /* current on-disk number of elements */

	unsigned new_length;    /* number of added elements */

	unsigned added_length;  /* space reserved for added elements */

	char *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;

	long entry_size; /* size of index headers. Differs in v1 v.s. v2 format

	                  */

	char format_version; /* size of index headers. Differs in v1 v.s. v2

	                        format */

};

static Py_ssize_t index_length(const indexObject *self)

{

	return self->length + self->new_length;

}

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

static const Py_ssize_t nullrev = -1;

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

static int index_find_node(indexObject *self, const char *node);

#if LONG_MAX == 0x7fffffffL

#else

#endif

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

static const long v1_entry_size = 64;

/* A Revlogv2 index entry is 96 bytes long. */

static const long v2_entry_size = 96;

static const long format_v1 = 1; /* Internal only, could be any number */

static const long format_v2 = 2; /* Internal only, could be any number */

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 (pos >= self->length)

		return self->added + (pos - self->length) * self->entry_size;

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

		if (self->offsets == NULL) {

			Py_ssize_t ret;

			self->offsets =

			    PyMem_Malloc(self->length * sizeof(*self->offsets));

			if (self->offsets == NULL)

				return (const char *)PyErr_NoMemory();

			ret = inline_scan(self, self->offsets);

			if (ret == -1) {

				return NULL;

			};

		}

		return self->offsets[pos];

	}

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

}

/*

 * Get parents of the given rev.

 *

 * The specified rev must be valid and must not be nullrev. A returned

 * parent revision may be nullrev, but is guaranteed to be in valid range.

 */

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

                                    int maxrev)

{

	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] < -1 || ps[0] > maxrev || ps[1] < -1 || ps[1] > maxrev) {

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

		return -1;

	}

	return 0;

}

/*

 * Get parents of the given rev.

 *

 * If the specified rev is out of range, IndexError will be raised. If the

 * revlog entry is corrupted, ValueError may be raised.

 *

 * Returns 0 on success or -1 on failure.

 */

static int HgRevlogIndex_GetParents(PyObject *op, int rev, int *ps)

{

	int tiprev;

	if (!op || !HgRevlogIndex_Check(op) || !ps) {

		PyErr_BadInternalCall();

		return -1;

	}

	tiprev = (int)index_length((indexObject *)op) - 1;

	if (rev < -1 || rev > tiprev) {

		PyErr_Format(PyExc_IndexError, "rev out of range: %d", rev);

		return -1;

	} else if (rev == -1) {

		ps[0] = ps[1] = -1;

		return 0;

	} else {

		return index_get_parents((indexObject *)op, rev, ps, tiprev);

	}

}

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

{

	const char *data;

	uint64_t offset;

	if (rev == nullrev)

		return 0;

	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)

{

	const char *data;

	int tmp;

	if (rev == nullrev)

		return 0;

	data = index_deref(self, rev);

	tmp = (int)getbe32(data + 8);

	if (tmp < 0) {

		PyErr_Format(PyExc_OverflowError,

		             "revlog entry size out of bound (%d)", tmp);

		return -1;

	}

	return tmp;

}

/*

 * 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 with SHA-1)

 */

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

{

	uint64_t offset_flags, sidedata_offset;

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

	    sidedata_comp_len;

	const char *c_node_id;

	const char *data;

	Py_ssize_t length = index_length(self);

	if (pos == nullrev) {

		Py_INCREF(self->nullentry);

		return self->nullentry;

	}

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

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

		return NULL;

	}

	data = index_deref(self, pos);

	if (data == NULL)

		return NULL;

	offset_flags = getbe32(data + 4);

	/*

	 * The first entry on-disk needs the version number masked out,

	 * but this doesn't apply if entries are added to an empty index.

	 */

	if (self->length && pos == 0)

		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;

	if (self->entry_size == v1_entry_size) {

		sidedata_offset = 0;

		sidedata_comp_len = 0;

	} else {

		sidedata_offset = getbe64(data + 64);

		sidedata_comp_len = getbe32(data + 72);

	}

	return Py_BuildValue(tuple_format, offset_flags, comp_len, uncomp_len,

	                     base_rev, link_rev, parent_1, parent_2, c_node_id,

}

/*

 * Pack header information in binary

 */

static PyObject *index_pack_header(indexObject *self, PyObject *args)

{

	int header;

	char out[4];

	if (!PyArg_ParseTuple(args, "I", &header)) {

		return NULL;

	}

	if (self->format_version != format_v1) {

		PyErr_Format(PyExc_RuntimeError,

		             "version header should go in the docket, not the "

		             "index: %lu",

		             header);

		return NULL;

	}

	putbe32(header, out);

	return PyBytes_FromStringAndSize(out, 4);

}

/*

 * Return the raw binary string representing a revision

 */

static PyObject *index_entry_binary(indexObject *self, PyObject *value)

{

	long rev;

	const char *data;

	Py_ssize_t length = index_length(self);

	if (!pylong_to_long(value, &rev)) {

		return NULL;

	}

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

		PyErr_Format(PyExc_ValueError, "revlog index out of range: %ld",

		             rev);

		return NULL;

	};

	data = index_deref(self, rev);

	if (data == NULL)

		return NULL;

	if (rev == 0 && self->format_version == format_v1) {

		/* the header is eating the start of the first entry */

		return PyBytes_FromStringAndSize(data + 4,

		                                 self->entry_size - 4);

	}

	return PyBytes_FromStringAndSize(data, self->entry_size);

}

/*

 * Return the hash of 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 == nullrev)

		return nullid;

	if (pos >= length)

		return NULL;

	data = index_deref(self, pos);

	return data ? data + 32 : NULL;

}

/*

 * Return the hash 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(Py_ssize_t nodelen, PyObject *obj, char **node)

{

	Py_ssize_t thisnodelen;

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

		return -1;

	if (nodelen == thisnodelen)

		return 0;

	PyErr_Format(PyExc_ValueError, "node len %zd != expected node len %zd",

	             thisnodelen, nodelen);

	return -1;

}

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

{

	uint64_t offset_flags, sidedata_offset;

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

	Py_ssize_t c_node_id_len, sidedata_comp_len;

	const char *c_node_id;

	char *data;

	if (!PyArg_ParseTuple(obj, tuple_format, &offset_flags, &comp_len,

	                      &uncomp_len, &base_rev, &link_rev, &parent_1,

	                      &parent_2, &c_node_id, &c_node_id_len,

		return NULL;

	}

	if (c_node_id_len != self->nodelen) {

		PyErr_SetString(PyExc_TypeError, "invalid node");

		return NULL;

	}

	if (self->new_length == self->added_length) {

		size_t new_added_length =

		    self->added_length ? self->added_length * 2 : 4096;

		void *new_added = PyMem_Realloc(

		    self->added, new_added_length * self->entry_size);

		if (!new_added)

			return PyErr_NoMemory();