/*

 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 "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

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

}

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)      /* header */

    "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, PY23("O!O!s#:parse_dirstate", "O!O!y#: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(PY23("s#s#", "y#y#"), 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!O!i:pack_dirstate", &PyDict_Type, &map,

	                      &PyDict_Type, &copymap, &PyTuple_Type, &pl, &now))

		return NULL;

	if (PyTuple_Size(pl) != 2) {

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

		return NULL;

	}

	/* Figure out how much we need to allocate. */

	for (nbytes = 40, pos = 0; PyDict_Next(map, &pos, &k, &v);) {

		PyObject *c;

		if (!PyBytes_Check(k)) {

			PyErr_SetString(PyExc_TypeError, "expected string key");

			goto bail;

		}

		nbytes += PyBytes_GET_SIZE(k) + 17;

		c = PyDict_GetItem(copymap, k);

		if (c) {

			if (!PyBytes_Check(c)) {

				PyErr_SetString(PyExc_TypeError,

				                "expected string key");

				goto bail;

			}

			nbytes += PyBytes_GET_SIZE(c) + 1;

		}

	}

	packobj = PyBytes_FromStringAndSize(NULL, nbytes);

	if (packobj == NULL)

		goto bail;

	p = PyBytes_AS_STRING(packobj);

	pn = PyTuple_GET_ITEM(pl, 0);

	if (PyBytes_AsStringAndSize(pn, &s, &l) == -1 || l != 20) {

		PyErr_SetString(PyExc_TypeError, "expected a 20-byte hash");

		goto bail;

	}

	memcpy(p, s, l);

	p += 20;

	pn = PyTuple_GET_ITEM(pl, 1);

	if (PyBytes_AsStringAndSize(pn, &s, &l) == -1 || l != 20) {

		PyErr_SetString(PyExc_TypeError, "expected a 20-byte hash");

		goto bail;

	}

	memcpy(p, s, l);

	p += 20;

	for (pos = 0; PyDict_Next(map, &pos, &k, &v);) {

		dirstateTupleObject *tuple;

		char state;

		int mode, size, mtime;

		Py_ssize_t len, l;

		PyObject *o;

		char *t;

		if (!dirstate_tuple_check(v)) {

			PyErr_SetString(PyExc_TypeError,

			                "expected a dirstate tuple");

			goto bail;

		}

		tuple = (dirstateTupleObject *)v;

		state = tuple->state;

		mode = tuple->mode;

		size = tuple->size;

		mtime = tuple->mtime;

		if (state == 'n' && mtime == now) {

			/* See pure/parsers.py:pack_dirstate for why we do

			 * this. */

			mtime = -1;

			mtime_unset = (PyObject *)make_dirstate_tuple(

			    state, mode, size, mtime);

			if (!mtime_unset)

				goto bail;