/*

 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 <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 const int dirstate_v1_from_p2 = -2;

static const int dirstate_v1_nonnormal = -1;

static const int ambiguous_time = -1;

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 dirstateItemObject *make_dirstate_item(char state, int mode,

                                                     int size, int mtime)

{

	dirstateItemObject *t =

	    PyObject_New(dirstateItemObject, &dirstateItemType);

	if (!t) {

		return NULL;

	}

	t->state = state;

	t->mode = mode;

	t->size = size;

	t->mtime = mtime;

	return t;

}

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

                                   PyObject *kwds)

{

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

	 * dirstate_item is immutable. */

	dirstateItemObject *t;

	char state;

	int size, mode, mtime;

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

		return NULL;

	}

	t = (dirstateItemObject *)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_item_dealloc(PyObject *o)

{

	PyObject_Del(o);

}

static Py_ssize_t dirstate_item_length(PyObject *o)

{

	return 4;

}

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

{

	dirstateItemObject *t = (dirstateItemObject *)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_item_sq = {

    dirstate_item_length, /* sq_length */

    0,                    /* sq_concat */

    0,                    /* sq_repeat */

    dirstate_item_item,   /* sq_item */

    0,                    /* sq_ass_item */

    0,                    /* sq_contains */

    0,                    /* sq_inplace_concat */

    0                     /* sq_inplace_repeat */

};

static PyObject *dirstate_item_v1_state(dirstateItemObject *self)

{

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

};

static PyObject *dirstate_item_v1_mode(dirstateItemObject *self)

{

	return PyInt_FromLong(self->mode);

};

static PyObject *dirstate_item_v1_size(dirstateItemObject *self)

{

	return PyInt_FromLong(self->size);

};

static PyObject *dirstate_item_v1_mtime(dirstateItemObject *self)

{

	return PyInt_FromLong(self->mtime);

};

static PyObject *dm_nonnormal(dirstateItemObject *self)

{

	if (self->state != 'n' || self->mtime == ambiguous_time) {

		Py_RETURN_TRUE;

	} else {

		Py_RETURN_FALSE;

	}

};

static PyObject *dm_otherparent(dirstateItemObject *self)

{

	if (self->size == dirstate_v1_from_p2) {

		Py_RETURN_TRUE;

	} else {

		Py_RETURN_FALSE;

	}

};

static PyObject *dirstate_item_need_delay(dirstateItemObject *self,

                                          PyObject *value)

{

	long now;

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

		return NULL;

	}

	if (self->state == 'n' && self->mtime == now) {

		Py_RETURN_TRUE;

	} else {

		Py_RETURN_FALSE;

	}

};

/* This will never change since it's bound to V1, unlike `make_dirstate_item`

 */

static inline dirstateItemObject *

dirstate_item_from_v1_data(char state, int mode, int size, int mtime)

{

	dirstateItemObject *t =

	    PyObject_New(dirstateItemObject, &dirstateItemType);

	if (!t) {

		return NULL;

	}

	t->state = state;

	t->mode = mode;

	t->size = size;

	t->mtime = mtime;

	return t;

}

/* This will never change since it's bound to V1, unlike `dirstate_item_new` */

static PyObject *dirstate_item_from_v1_meth(PyTypeObject *subtype,

                                            PyObject *args)

{

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

	 * dirstate_item is immutable. */

	dirstateItemObject *t;

	char state;

	int size, mode, mtime;

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

		return NULL;

	}

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

	if (!t) {

		return NULL;

	}

	t->state = state;

	t->mode = mode;

	t->size = size;

	t->mtime = mtime;

	return (PyObject *)t;

};

/* This means the next status call will have to actually check its content

   to make sure it is correct. */

static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self)

{

	self->mtime = ambiguous_time;

	Py_RETURN_NONE;

}

static PyMethodDef dirstate_item_methods[] = {

    {"v1_state", (PyCFunction)dirstate_item_v1_state, METH_NOARGS,

     "return a \"state\" suitable for v1 serialization"},

    {"v1_mode", (PyCFunction)dirstate_item_v1_mode, METH_NOARGS,

     "return a \"mode\" suitable for v1 serialization"},

    {"v1_size", (PyCFunction)dirstate_item_v1_size, METH_NOARGS,

     "return a \"size\" suitable for v1 serialization"},

    {"v1_mtime", (PyCFunction)dirstate_item_v1_mtime, METH_NOARGS,

     "return a \"mtime\" suitable for v1 serialization"},

    {"need_delay", (PyCFunction)dirstate_item_need_delay, METH_O,

     "True if the stored mtime would be ambiguous with the current time"},

    {"from_v1_data", (PyCFunction)dirstate_item_from_v1_meth, METH_O,

     "build a new DirstateItem object from V1 data"},

    {"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty,

     METH_NOARGS, "mark a file as \"possibly dirty\""},

    {"dm_nonnormal", (PyCFunction)dm_nonnormal, METH_NOARGS,

     "True is the entry is non-normal in the dirstatemap sense"},

    {"dm_otherparent", (PyCFunction)dm_otherparent, METH_NOARGS,

     "True is the entry is `otherparent` in the dirstatemap sense"},

    {NULL} /* Sentinel */

};

static PyObject *dirstate_item_get_mode(dirstateItemObject *self)

{

	return PyInt_FromLong(self->mode);

};

static PyObject *dirstate_item_get_size(dirstateItemObject *self)

{

	return PyInt_FromLong(self->size);

};

static PyObject *dirstate_item_get_mtime(dirstateItemObject *self)

{

	return PyInt_FromLong(self->mtime);

};

static PyObject *dirstate_item_get_state(dirstateItemObject *self)

{

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

};

static PyObject *dirstate_item_get_tracked(dirstateItemObject *self)

{

	if (self->state == 'a' || self->state == 'm' || self->state == 'n') {

		Py_RETURN_TRUE;

	} else {

		Py_RETURN_FALSE;

	}

};

static PyObject *dirstate_item_get_added(dirstateItemObject *self)

{

	if (self->state == 'a') {

		Py_RETURN_TRUE;

	} else {

		Py_RETURN_FALSE;

	}

};

static PyObject *dirstate_item_get_merged(dirstateItemObject *self)

{

	if (self->state == 'm') {

		Py_RETURN_TRUE;

	} else {

		Py_RETURN_FALSE;

	}

};

static PyObject *dirstate_item_get_merged_removed(dirstateItemObject *self)

{

	if (self->state == 'r' && self->size == dirstate_v1_nonnormal) {

		Py_RETURN_TRUE;

	} else {

		Py_RETURN_FALSE;

	}

};

static PyObject *dirstate_item_get_from_p2(dirstateItemObject *self)

{

	if (self->state == 'n' && self->size == dirstate_v1_from_p2) {

		Py_RETURN_TRUE;

	} else {

		Py_RETURN_FALSE;

	}

};

static PyObject *dirstate_item_get_from_p2_removed(dirstateItemObject *self)

{

	if (self->state == 'r' && self->size == dirstate_v1_from_p2) {

		Py_RETURN_TRUE;

	} else {

		Py_RETURN_FALSE;

	}

};

static PyObject *dirstate_item_get_removed(dirstateItemObject *self)

{

	if (self->state == 'r') {

		Py_RETURN_TRUE;

	} else {

		Py_RETURN_FALSE;

	}

};

static PyGetSetDef dirstate_item_getset[] = {

    {"mode", (getter)dirstate_item_get_mode, NULL, "mode", NULL},

    {"size", (getter)dirstate_item_get_size, NULL, "size", NULL},

    {"mtime", (getter)dirstate_item_get_mtime, NULL, "mtime", NULL},

    {"state", (getter)dirstate_item_get_state, NULL, "state", NULL},

    {"tracked", (getter)dirstate_item_get_tracked, NULL, "tracked", NULL},

    {"added", (getter)dirstate_item_get_added, NULL, "added", NULL},

    {"merged_removed", (getter)dirstate_item_get_merged_removed, NULL,

     "merged_removed", NULL},

    {"merged", (getter)dirstate_item_get_merged, NULL, "merged", NULL},

    {"from_p2_removed", (getter)dirstate_item_get_from_p2_removed, NULL,

     "from_p2_removed", NULL},

    {"from_p2", (getter)dirstate_item_get_from_p2, NULL, "from_p2", NULL},

    {"removed", (getter)dirstate_item_get_removed, NULL, "removed", NULL},

    {NULL} /* Sentinel */

};

PyTypeObject dirstateItemType = {

    PyVarObject_HEAD_INIT(NULL, 0)     /* header */

    "dirstate_tuple",                  /* tp_name */

    sizeof(dirstateItemObject),        /* tp_basicsize */

    0,                                 /* tp_itemsize */

    (destructor)dirstate_item_dealloc, /* tp_dealloc */

    0,                                 /* tp_print */

    0,                                 /* tp_getattr */

    0,                                 /* tp_setattr */

    0,                                 /* tp_compare */

    0,                                 /* tp_repr */

    0,                                 /* tp_as_number */

    &dirstate_item_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 */