/*

 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 "charencode.h"

#include "util.h"

#include "bitmanipulation.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_Type PyLong_Type

#define PyInt_Check PyLong_Check

#define PyInt_FromLong PyLong_FromLong

#define PyInt_FromSsize_t PyLong_FromSsize_t

#define PyInt_AS_LONG PyLong_AS_LONG

#define PyInt_AsLong PyLong_AsLong

#endif

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

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

{

	Py_ssize_t expected_size;

	if (!PyArg_ParseTuple(args, "n:make_presized_dict", &expected_size))

		return NULL;

	return _dict_new_presized(expected_size);

}

/*

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

		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;

	len = readlen;

	/* read parents */

	if (len < 40) {

		PyErr_SetString(

			PyExc_ValueError, "too little data for parents");

		goto quit;

	}

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

	if (!parents)

		goto quit;

	/* read filenames */

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

		if (pos + 17 > len) {

			PyErr_SetString(PyExc_ValueError,

					"overflow in dirstate");

			goto quit;

		}

		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;

}

/*

 * Build a set of non-normal and other parent entries from the dirstate dmap

*/

static PyObject *nonnormalotherparententries(PyObject *self, PyObject *args) {

	PyObject *dmap, *fname, *v;

	PyObject *nonnset = NULL, *otherpset = NULL, *result = NULL;

	Py_ssize_t pos;

	if (!PyArg_ParseTuple(args, "O!:nonnormalentries",

			      &PyDict_Type, &dmap))

		goto bail;

	nonnset = PySet_New(NULL);

	if (nonnset == NULL)

		goto bail;

	otherpset = PySet_New(NULL);

	if (otherpset == NULL)

		goto bail;

	pos = 0;

	while (PyDict_Next(dmap, &pos, &fname, &v)) {

		dirstateTupleObject *t;

		if (!dirstate_tuple_check(v)) {

			PyErr_SetString(PyExc_TypeError,

					"expected a dirstate tuple");

			goto bail;

		}

		t = (dirstateTupleObject *)v;

		if (t->state == 'n' && t->size == -2) {

			if (PySet_Add(otherpset, fname) == -1) {

				goto bail;

			}

		}

		if (t->state == 'n' && t->mtime != -1)

			continue;

		if (PySet_Add(nonnset, fname) == -1)

			goto bail;

	}

	result = Py_BuildValue("(OO)", nonnset, otherpset);

	if (result == NULL)

		goto bail;

	Py_DECREF(nonnset);

	Py_DECREF(otherpset);

	return result;

bail:

	Py_XDECREF(nonnset);

	Py_XDECREF(otherpset);

	Py_XDECREF(result);

	return NULL;

}

/*

 * 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 = NULL, *pn;

	char *p, *s;

	int now;

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

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