/*

 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;

	PyObject *parentfiledata;

	static char *keywords_name[] = {

	};

	wc_tracked = 0;

	p1_tracked = 0;

	parentfiledata = Py_None;

		return NULL;

	}

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

	if (!t) {

		return NULL;

	}

	t->flags = 0;

	if (wc_tracked) {

		t->flags |= dirstate_flag_wc_tracked;

	}

	if (p1_tracked) {

		t->flags |= dirstate_flag_p1_tracked;

	}

	}

	if (parentfiledata != Py_None) {

		if (!PyTuple_CheckExact(parentfiledata)) {

			PyErr_SetString(

			    PyExc_TypeError,

			    "parentfiledata should be a Tuple or None");

			return NULL;

		}

	}

	return (PyObject *)t;

}

static void dirstate_item_dealloc(PyObject *o)

{

	PyObject_Del(o);

}

static inline bool dirstate_item_c_tracked(dirstateItemObject *self)

{

	return (self->flags & dirstate_flag_wc_tracked);

}

static inline bool dirstate_item_c_added(dirstateItemObject *self)

{

	    (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |

	return (self->flags & mask) == target;

}

static inline bool dirstate_item_c_removed(dirstateItemObject *self)

{

	if (self->flags & dirstate_flag_wc_tracked) {

		return false;

	}

	return (self->flags &

}

static inline bool dirstate_item_c_merged(dirstateItemObject *self)

{

	return ((self->flags & dirstate_flag_wc_tracked) &&

}

static inline bool dirstate_item_c_from_p2(dirstateItemObject *self)

{

}

static inline char dirstate_item_c_v1_state(dirstateItemObject *self)

{

	if (dirstate_item_c_removed(self)) {

		return 'r';

	} else if (dirstate_item_c_merged(self)) {

		return 'm';

	} else if (dirstate_item_c_added(self)) {

		return 'a';

	} else {

		return 'n';

	}

}

static inline int dirstate_item_c_v1_mode(dirstateItemObject *self)

{

}

static inline int dirstate_item_c_v1_size(dirstateItemObject *self)

{

	} else if (dirstate_item_c_removed(self)) {

		return 0;

		return dirstate_v1_from_p2;

	} else if (dirstate_item_c_added(self)) {

		return dirstate_v1_nonnormal;

	} else {

	}

}

static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self)

{

	if (dirstate_item_c_removed(self)) {

		return 0;

		return ambiguous_time;

	} else {

		return self->mtime;

	}

}

static PyObject *dirstate_item_v1_state(dirstateItemObject *self)

{

	char state = dirstate_item_c_v1_state(self);

	return PyBytes_FromStringAndSize(&state, 1);

};

static PyObject *dirstate_item_v1_mode(dirstateItemObject *self)

{

	return PyInt_FromLong(dirstate_item_c_v1_mode(self));

};

static PyObject *dirstate_item_v1_size(dirstateItemObject *self)

{

	return PyInt_FromLong(dirstate_item_c_v1_size(self));

};

static PyObject *dirstate_item_v1_mtime(dirstateItemObject *self)

{

	return PyInt_FromLong(dirstate_item_c_v1_mtime(self));

};

static PyObject *dirstate_item_need_delay(dirstateItemObject *self,

                                          PyObject *value)

{

	long now;

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

		return NULL;

	}

	if (dirstate_item_c_v1_state(self) == 'n' &&

	    dirstate_item_c_v1_mtime(self) == now) {

		Py_RETURN_TRUE;

	} else {

		Py_RETURN_FALSE;

	}

};

/* This will never change since it's bound to V1

 */

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;

	}

	if (state == 'm') {

	} else if (state == 'a') {

		t->flags = dirstate_flag_wc_tracked;

	} else if (state == 'r') {

		if (size == dirstate_v1_nonnormal) {

			t->flags =

		} else if (size == dirstate_v1_from_p2) {

		} else {

			t->flags = dirstate_flag_p1_tracked;

		}

	} else if (state == 'n') {

		if (size == dirstate_v1_from_p2) {

			t->flags =

		} else if (size == dirstate_v1_nonnormal) {

		} else if (mtime == ambiguous_time) {

			t->flags = (dirstate_flag_wc_tracked |

			            dirstate_flag_p1_tracked |

			t->mode = mode;

			t->size = size;

		} else {

			t->flags = (dirstate_flag_wc_tracked |

			t->mode = mode;

			t->size = size;

			t->mtime = mtime;

		}

	} else {

		PyErr_Format(PyExc_RuntimeError,

		             "unknown state: `%c` (%d, %d, %d)", state, mode,

		             size, mtime, NULL);

		Py_DECREF(t);

		return NULL;

	}

	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. */

	char state;

	int size, mode, mtime;

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

		return NULL;

	}

	return (PyObject *)dirstate_item_from_v1_data(state, mode, size, mtime);

};

/* 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->flags = dirstate_flag_wc_tracked;

	t->mode = 0;

	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->flags = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |

	t->mode = 0;

	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)