/*

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

	int wc_tracked;

	int p1_tracked;

	int p2_tracked;

	int merged;

	int clean_p1;

	int clean_p2;

	int possibly_dirty;

	PyObject *parentfiledata;

	static char *keywords_name[] = {

	    "wc_tracked",     "p1_tracked",     "p2_tracked",

	    "merged",         "clean_p1",       "clean_p2",

	    "possibly_dirty", "parentfiledata", NULL,

	};

	wc_tracked = 0;

	p1_tracked = 0;

	p2_tracked = 0;

	merged = 0;

	clean_p1 = 0;

	clean_p2 = 0;

	possibly_dirty = 0;

	parentfiledata = Py_None;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "iiiiiiiO", keywords_name,

	                                 &wc_tracked, &p1_tracked, &p2_tracked,

	                                 &merged, &clean_p1, &clean_p2,

	                                 &possibly_dirty, &parentfiledata

	                                 )) {

		return NULL;

	}

	if (merged && (clean_p1 || clean_p2)) {

		PyErr_SetString(PyExc_RuntimeError,

		                "`merged` argument incompatible with "

		                "`clean_p1`/`clean_p2`");

		return NULL;

	}

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

	if (!t) {

		return NULL;

	}

	t->state = 'r';

	t->mode = 0;

	t->size = dirstate_v1_nonnormal;

	t->mtime = ambiguous_time;

	if (!(p1_tracked || p2_tracked || wc_tracked)) {

		/* Nothing special to do, file is untracked */

	} else if (merged) {

		t->state = 'm';

		t->size = dirstate_v1_from_p2;

		t->mtime = ambiguous_time;

	} else if (!(p1_tracked || p2_tracked) && wc_tracked) {

		t->state = 'a';

		t->size = dirstate_v1_nonnormal;

		t->mtime = ambiguous_time;

	} else if ((p1_tracked || p2_tracked) && !wc_tracked) {

		t->state = 'r';

		t->size = 0;

		t->mtime = 0;

	} else if (clean_p2 && wc_tracked) {

		t->state = 'n';

		t->size = dirstate_v1_from_p2;

		t->mtime = ambiguous_time;

	} else if (!p1_tracked && p2_tracked && wc_tracked) {

		t->state = 'n';

		t->size = dirstate_v1_from_p2;

		t->mtime = ambiguous_time;

	} else if (possibly_dirty) {

		t->state = 'n';

		t->size = dirstate_v1_nonnormal;

		t->mtime = ambiguous_time;

	} else if (wc_tracked) {

		/* this is a "normal" file */

		if (parentfiledata == Py_None) {

			PyErr_SetString(

			    PyExc_RuntimeError,

			    "failed to pass parentfiledata for a normal file");

			return NULL;

		}

		if (!PyTuple_CheckExact(parentfiledata)) {

			PyErr_SetString(

			    PyExc_TypeError,

			    "parentfiledata should be a Tuple or None");

			return NULL;

		}

		t->state = 'n';

		t->mode =

		    (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 0));

		t->size =

		    (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 1));

		t->mtime =

		    (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 2));

	} else {

		PyErr_SetString(PyExc_RuntimeError, "unreachable");

		return NULL;

	}

	return (PyObject *)t;

}

static void dirstate_item_dealloc(PyObject *o)

{

	PyObject_Del(o);

}

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

	}

};

 */

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;

};

/* constructor to help legacy API to build a new "added" item

Should eventually be removed */

static PyObject *dirstate_item_new_added(PyTypeObject *subtype)

{

	dirstateItemObject *t;

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

	if (!t) {

		return NULL;

	}

	t->state = 'a';

	t->mode = 0;

	t->size = dirstate_v1_nonnormal;

	t->mtime = ambiguous_time;

	return (PyObject *)t;

};

/* constructor to help legacy API to build a new "merged" item

Should eventually be removed */

static PyObject *dirstate_item_new_merged(PyTypeObject *subtype)

{

	dirstateItemObject *t;

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

	if (!t) {

		return NULL;

	}

	t->state = 'm';

	t->mode = 0;

	t->size = dirstate_v1_from_p2;

	t->mtime = ambiguous_time;

	return (PyObject *)t;

};

/* constructor to help legacy API to build a new "from_p2" item

Should eventually be removed */

static PyObject *dirstate_item_new_from_p2(PyTypeObject *subtype)

{

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

	 * dirstate_item is immutable. */

	dirstateItemObject *t;

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

	if (!t) {

		return NULL;

	}

	t->state = 'n';

	t->mode = 0;

	t->size = dirstate_v1_from_p2;

	t->mtime = ambiguous_time;

	return (PyObject *)t;

};

/* constructor to help legacy API to build a new "possibly" item

Should eventually be removed */

static PyObject *dirstate_item_new_possibly_dirty(PyTypeObject *subtype)

{

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

	 * dirstate_item is immutable. */

	dirstateItemObject *t;

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

	if (!t) {

		return NULL;

	}

	t->state = 'n';

	t->mode = 0;

	t->size = dirstate_v1_nonnormal;

	t->mtime = ambiguous_time;

	return (PyObject *)t;

};

/* constructor to help legacy API to build a new "normal" item

Should eventually be removed */

static PyObject *dirstate_item_new_normal(PyTypeObject *subtype, PyObject *args)

{

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

	 * dirstate_item is immutable. */

	dirstateItemObject *t;

	int size, mode, mtime;

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

		return NULL;

	}

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

	if (!t) {

		return NULL;

	}

	t->state = 'n';

	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 PyObject *dirstate_item_set_untracked(dirstateItemObject *self)

{

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

		self->size = dirstate_v1_nonnormal;

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

		self->size = dirstate_v1_from_p2;

	} else {

		self->size = 0;

	}

	self->state = 'r';

	self->mode = 0;

	self->mtime = 0;

	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_VARARGS | METH_CLASS, "build a new DirstateItem object from V1 data"},

    {"new_added", (PyCFunction)dirstate_item_new_added,

     METH_NOARGS | METH_CLASS,

     "constructor to help legacy API to build a new \"added\" item"},

    {"new_merged", (PyCFunction)dirstate_item_new_merged,

     METH_NOARGS | METH_CLASS,

     "constructor to help legacy API to build a new \"merged\" item"},

    {"new_from_p2", (PyCFunction)dirstate_item_new_from_p2,

     METH_NOARGS | METH_CLASS,

     "constructor to help legacy API to build a new \"from_p2\" item"},

    {"new_possibly_dirty", (PyCFunction)dirstate_item_new_possibly_dirty,

     METH_NOARGS | METH_CLASS,

     "constructor to help legacy API to build a new \"possibly_dirty\" item"},

    {"new_normal", (PyCFunction)dirstate_item_new_normal,

     METH_VARARGS | METH_CLASS,

     "constructor to help legacy API to build a new \"normal\" item"},

    {"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty,

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

    {"set_untracked", (PyCFunction)dirstate_item_set_untracked, METH_NOARGS,

     "mark a file as \"untracked\""},

    {NULL} /* Sentinel */

};

static PyObject *dirstate_item_get_mode(dirstateItemObject *self)

{