/*

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

#include <string.h>

#include "util.h"

static char *versionerrortext = "Python minor version mismatch";

static int8_t hextable[256] = {

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1, /* 0-9 */

	-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* A-F */

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* a-f */

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1

};

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

{

	int8_t val = hextable[(unsigned char)p[off]];

	if (val >= 0) {

		return val;

	}

	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, *start, *end;

	int len;

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

			      &PyDict_Type, &mfdict,

			      &PyDict_Type, &fdict,

			      &str, &len))

		goto quit;

	start = str;

	end = str + len;

	while (start < end) {

		PyObject *file = NULL, *node = NULL;

		PyObject *flags = NULL;

		char *zero = NULL, *newline = NULL;

		ptrdiff_t nlen;

		zero = memchr(start, '\0', end - start);

		if (!zero) {

			PyErr_SetString(PyExc_ValueError,

					"manifest entry has no separator");

			goto quit;

		}

		newline = memchr(zero + 1, '\n', end - (zero + 1));

		if (!newline) {

			PyErr_SetString(PyExc_ValueError,

					"manifest contains trailing garbage");

			goto quit;

		}

		file = PyBytes_FromStringAndSize(start, zero - start);

		if (!file)

			goto bail;

		nlen = newline - zero - 1;

		node = unhexlify(zero + 1, nlen > 40 ? 40 : (int)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 = newline + 1;

		Py_XDECREF(flags);

		Py_XDECREF(node);

		Py_XDECREF(file);

		continue;

	bail:

		Py_XDECREF(flags);

		Py_XDECREF(node);

		Py_XDECREF(file);

		goto quit;

	}

	Py_INCREF(Py_None);

	return Py_None;

quit:

	return NULL;

}

static inline dirstateTupleObject *make_dirstate_tuple(char state, int mode,

						       int size, int mtime)

{

	dirstateTupleObject *t = PyObject_New(dirstateTupleObject,

					      &dirstateTupleType);

	if (!t)

		return NULL;

	t->state = state;

	t->mode = mode;

	t->size = size;

	t->mtime = mtime;

	return t;

}

static PyObject *dirstate_tuple_new(PyTypeObject *subtype, PyObject *args,

				    PyObject *kwds)

{

	/* We do all the initialization here and not a tp_init function because

	 * dirstate_tuple is immutable. */

	dirstateTupleObject *t;

	char state;

	int size, mode, mtime;

	if (!PyArg_ParseTuple(args, "ciii", &state, &mode, &size, &mtime))

		return NULL;

	t = (dirstateTupleObject *)subtype->tp_alloc(subtype, 1);

	if (!t)

		return NULL;

	t->state = state;

	t->mode = mode;

	t->size = size;

	t->mtime = mtime;

	return (PyObject *)t;

}

static void dirstate_tuple_dealloc(PyObject *o)

{

	PyObject_Del(o);

}

static Py_ssize_t dirstate_tuple_length(PyObject *o)

{

	return 4;

}

static PyObject *dirstate_tuple_item(PyObject *o, Py_ssize_t i)

{

	dirstateTupleObject *t = (dirstateTupleObject *)o;

	switch (i) {

	case 0:

		return PyBytes_FromStringAndSize(&t->state, 1);

	case 1:

		return PyInt_FromLong(t->mode);

	case 2:

		return PyInt_FromLong(t->size);

	case 3:

		return PyInt_FromLong(t->mtime);

	default:

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

		return NULL;

	}

}

static PySequenceMethods dirstate_tuple_sq = {

	dirstate_tuple_length,     /* sq_length */

	0,                         /* sq_concat */

	0,                         /* sq_repeat */

	dirstate_tuple_item,       /* sq_item */

	0,                         /* sq_ass_item */

	0,                         /* sq_contains */

	0,                         /* sq_inplace_concat */

	0                          /* sq_inplace_repeat */

};

PyTypeObject dirstateTupleType = {

	PyVarObject_HEAD_INIT(NULL, 0)

	"dirstate_tuple",          /* tp_name */

	sizeof(dirstateTupleObject),/* tp_basicsize */

	0,                         /* tp_itemsize */

	(destructor)dirstate_tuple_dealloc, /* tp_dealloc */

	0,                         /* tp_print */

	0,                         /* tp_getattr */

	0,                         /* tp_setattr */

	0,                         /* tp_compare */

	0,                         /* tp_repr */

	0,                         /* tp_as_number */

	&dirstate_tuple_sq,        /* tp_as_sequence */

	0,                         /* tp_as_mapping */

	0,                         /* tp_hash  */

	0,                         /* tp_call */

	0,                         /* tp_str */

	0,                         /* tp_getattro */

	0,                         /* tp_setattro */

	0,                         /* tp_as_buffer */

	Py_TPFLAGS_DEFAULT,        /* tp_flags */

	"dirstate tuple",          /* tp_doc */

	0,                         /* tp_traverse */

	0,                         /* tp_clear */

	0,                         /* tp_richcompare */

	0,                         /* tp_weaklistoffset */

	0,                         /* tp_iter */

	0,                         /* tp_iternext */

	0,                         /* tp_methods */

	0,                         /* tp_members */

	0,                         /* tp_getset */

	0,                         /* tp_base */

	0,                         /* tp_dict */

	0,                         /* tp_descr_get */

	0,                         /* tp_descr_set */

	0,                         /* tp_dictoffset */

	0,                         /* tp_init */

	0,                         /* tp_alloc */

	dirstate_tuple_new,        /* tp_new */

};

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

{

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

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

	char state, *cur, *str, *cpos;

	int mode, size, mtime;

	unsigned int flen, len, pos = 40;

	int readlen;

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

			      &PyDict_Type, &dmap,

			      &PyDict_Type, &cmap,

			      &str, &readlen))

		goto quit;

	if (readlen < 0)

		goto quit;

	len = readlen;

	/* read parents */

	if (len < 40)

		goto quit;

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

	if (!parents)

		goto quit;

	/* read filenames */

	while (pos >= 40 && pos < len) {

		cur = str + pos;

		/* unpack header */

		state = *cur;

		mode = getbe32(cur + 1);

		size = getbe32(cur + 5);

		mtime = getbe32(cur + 9);

		flen = getbe32(cur + 13);

		pos += 17;

		cur += 17;

		if (flen > len - pos) {

			PyErr_SetString(PyExc_ValueError, "overflow in dirstate");

			goto quit;

		}

		entry = (PyObject *)make_dirstate_tuple(state, mode, size,

							mtime);

		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;

		}

		Py_DECREF(fname);

		Py_DECREF(entry);

		fname = cname = entry = NULL;

		pos += flen;

	}

	ret = parents;

	Py_INCREF(ret);

quit:

	Py_XDECREF(fname);

	Py_XDECREF(cname);

	Py_XDECREF(entry);

	Py_XDECREF(parents);

	return ret;

}

/*

 * Efficiently pack a dirstate object into its on-disk format.

 */

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

{

	PyObject *packobj = NULL;

	PyObject *map, *copymap, *pl, *mtime_unset = NULL;

	Py_ssize_t nbytes, pos, l;

	PyObject *k, *v, *pn;

	char *p, *s;

	double now;

	if (!PyArg_ParseTuple(args, "O!O!Od:pack_dirstate",

			      &PyDict_Type, &map, &PyDict_Type, &copymap,

			      &pl, &now))

		return NULL;

	if (!PySequence_Check(pl) || PySequence_Size(pl) != 2) {

		PyErr_SetString(PyExc_TypeError, "expected 2-element sequence");

		return NULL;

	}