/*

 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 <ctype.h>

#include <string.h>

#include "util.h"

static inline int hexdigit(const char *p, Py_ssize_t off)

{

	char c = p[off];

	if (c >= '0' && c <= '9')

		return c - '0';

	if (c >= 'a' && c <= 'f')

		return c - 'a' + 10;

	if (c >= 'A' && c <= 'F')

		return c - 'A' + 10;

	PyErr_SetString(PyExc_ValueError, "input contains non-hex character");

	return 0;

}

/*

 * Turn a hex-encoded string into binary.

 */

static PyObject *unhexlify(const char *str, int len)

{

	PyObject *ret;

	char *d;

	int i;

	ret = PyBytes_FromStringAndSize(NULL, len / 2);

	if (!ret)

		return NULL;

	d = PyBytes_AsString(ret);

	for (i = 0; i < len;) {

		int hi = hexdigit(str, i++);

		int lo = hexdigit(str, i++);

		*d++ = (hi << 4) | lo;

	}

	return ret;

}

/*

 * This code assumes that a manifest is stitched together with newline

 * ('\n') characters.

 */

static PyObject *parse_manifest(PyObject *self, PyObject *args)

{

	PyObject *mfdict, *fdict;

	char *str, *cur, *start, *zero;

	int len;

	if (!PyArg_ParseTuple(args, "O!O!s#:parse_manifest",

			      &PyDict_Type, &mfdict,

			      &PyDict_Type, &fdict,

			      &str, &len))

		goto quit;

	for (start = cur = str, zero = NULL; cur < str + len; cur++) {

		PyObject *file = NULL, *node = NULL;

		PyObject *flags = NULL;

		int nlen;

		if (!*cur) {

			zero = cur;

			continue;

		}

		else if (*cur != '\n')

			continue;

		if (!zero) {

			PyErr_SetString(PyExc_ValueError,

					"manifest entry has no separator");

			goto quit;

		}

		file = PyBytes_FromStringAndSize(start, zero - start);

		if (!file)

			goto bail;

		nlen = cur - zero - 1;

		node = unhexlify(zero + 1, nlen > 40 ? 40 : nlen);

		if (!node)

			goto bail;

		if (nlen > 40) {

			flags = PyBytes_FromStringAndSize(zero + 41,

							   nlen - 40);

			if (!flags)

				goto bail;

			if (PyDict_SetItem(fdict, file, flags) == -1)

				goto bail;

		}

		if (PyDict_SetItem(mfdict, file, node) == -1)

			goto bail;

		start = cur + 1;

		zero = NULL;

		Py_XDECREF(flags);

		Py_XDECREF(node);

		Py_XDECREF(file);

		continue;

	bail:

		Py_XDECREF(flags);

		Py_XDECREF(node);

		Py_XDECREF(file);

		goto quit;

	}

	if (len > 0 && *(cur - 1) != '\n') {

		PyErr_SetString(PyExc_ValueError,

				"manifest contains trailing garbage");

		goto quit;

	}

	Py_INCREF(Py_None);

	return Py_None;

quit:

	return NULL;

}

static PyObject *parse_dirstate(PyObject *self, PyObject *args)

{

	PyObject *dmap, *cmap, *parents = NULL, *ret = NULL;

	PyObject *fname = NULL, *cname = NULL, *entry = NULL;

	char *str, *cur, *end, *cpos;

	int state, mode, size, mtime;

	unsigned int flen;

	int len;

	if (!PyArg_ParseTuple(args, "O!O!s#:parse_dirstate",

			      &PyDict_Type, &dmap,

			      &PyDict_Type, &cmap,

			      &str, &len))

		goto quit;

	/* read parents */

	if (len < 40)

		goto quit;

	parents = Py_BuildValue("s#s#", str, 20, str + 20, 20);

	if (!parents)

		goto quit;

	/* read filenames */

	cur = str + 40;

	end = str + len;

	while (cur < end - 17) {

		/* unpack header */

		state = *cur;

		mode = getbe32(cur + 1);

		size = getbe32(cur + 5);

		mtime = getbe32(cur + 9);

		flen = getbe32(cur + 13);

		cur += 17;

		if (cur + flen > end || cur + flen < cur) {

			PyErr_SetString(PyExc_ValueError, "overflow in dirstate");

			goto quit;

		}

		entry = Py_BuildValue("ciii", state, mode, size, mtime);

		if (!entry)

			goto quit;

		PyObject_GC_UnTrack(entry); /* don't waste time with this */

		cpos = memchr(cur, 0, flen);

		if (cpos) {

			fname = PyBytes_FromStringAndSize(cur, cpos - cur);

			cname = PyBytes_FromStringAndSize(cpos + 1,

							   flen - (cpos - cur) - 1);

			if (!fname || !cname ||

			    PyDict_SetItem(cmap, fname, cname) == -1 ||

			    PyDict_SetItem(dmap, fname, entry) == -1)

				goto quit;

			Py_DECREF(cname);

		} else {

			fname = PyBytes_FromStringAndSize(cur, flen);

			if (!fname ||

			    PyDict_SetItem(dmap, fname, entry) == -1)

				goto quit;

		}

		cur += flen;

		Py_DECREF(fname);

		Py_DECREF(entry);

		fname = cname = entry = NULL;

	}

	ret = parents;

	Py_INCREF(ret);

quit:

	Py_XDECREF(fname);

	Py_XDECREF(cname);

	Py_XDECREF(entry);

	Py_XDECREF(parents);

	return ret;

}

/*

 * 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 + 1)

 * Zero is empty

 */

typedef struct {

	int children[16];

} nodetree;

/*

 * This class has two behaviours.

 *

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

 */