/*

 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->flags = 0;

	if (wc_tracked) {

		t->flags |= dirstate_flag_wc_tracked;

	}

	if (p1_tracked) {

		t->flags |= dirstate_flag_p1_tracked;

	}

	if (p2_tracked) {

		t->flags |= dirstate_flag_p2_tracked;

	}

	if (possibly_dirty) {

		t->flags |= dirstate_flag_possibly_dirty;

	}

	if (merged) {

		t->flags |= dirstate_flag_merged;

	}

	if (clean_p1) {

		t->flags |= dirstate_flag_clean_p1;

	}

	if (clean_p2) {

		t->flags |= dirstate_flag_clean_p2;

	}

	t->mode = 0;

	t->size = dirstate_v1_nonnormal;

	t->mtime = ambiguous_time;

	if (parentfiledata != Py_None) {

		if (!PyTuple_CheckExact(parentfiledata)) {

			PyErr_SetString(

			    PyExc_TypeError,

			    "parentfiledata should be a Tuple or None");

			return NULL;

		}

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

	}

	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)

{

	char mask = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |

	             dirstate_flag_p2_tracked);

	char target = dirstate_flag_wc_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 &

	        (dirstate_flag_p1_tracked | dirstate_flag_p2_tracked));

}

static inline bool dirstate_item_c_merged(dirstateItemObject *self)

{

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

	        (self->flags & dirstate_flag_merged));

}

static inline bool dirstate_item_c_merged_removed(dirstateItemObject *self)

{

	if (!dirstate_item_c_removed(self)) {

		return false;

	}

	return (self->flags & dirstate_flag_merged);

}

static inline bool dirstate_item_c_from_p2(dirstateItemObject *self)

{

	if (!dirstate_item_c_tracked(self)) {

		return false;

	}

	return (self->flags & dirstate_flag_clean_p2);

}

static inline bool dirstate_item_c_from_p2_removed(dirstateItemObject *self)

{

	if (!dirstate_item_c_removed(self)) {

		return false;

	}

	return (self->flags & dirstate_flag_clean_p2);

}

static inline char dirstate_item_c_v1_state(dirstateItemObject *self)

{

	if (self->flags & dirstate_flag_rust_special) {

		return ' ';

	} else 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)

{

	return self->mode;

}

static inline int dirstate_item_c_v1_size(dirstateItemObject *self)

{

	if (self->flags & dirstate_flag_rust_special) {

		return self->size;

	} else if (dirstate_item_c_merged_removed(self)) {

		return dirstate_v1_nonnormal;

	} else if (dirstate_item_c_from_p2_removed(self)) {

		return dirstate_v1_from_p2;

	} else if (dirstate_item_c_removed(self)) {

		return 0;

	} else if (dirstate_item_c_merged(self)) {

		return dirstate_v1_from_p2;

	} else if (dirstate_item_c_added(self)) {

		return dirstate_v1_nonnormal;

	} else if (dirstate_item_c_from_p2(self)) {

		return dirstate_v1_from_p2;

	} else if (self->flags & dirstate_flag_possibly_dirty) {

		return self->size; /* NON NORMAL ? */

	} else {

		return self->size;

	}

}

static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self)

{

	if (self->flags & dirstate_flag_rust_special) {

		return self->mtime;

	} else if (dirstate_item_c_removed(self)) {

		return 0;

	} else if (self->flags & dirstate_flag_possibly_dirty) {

		return ambiguous_time;

	} else if (dirstate_item_c_merged(self)) {

		return ambiguous_time;

	} else if (dirstate_item_c_added(self)) {

		return ambiguous_time;

	} else if (dirstate_item_c_from_p2(self)) {

		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') {

		t->flags =

		    (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |

		     dirstate_flag_p2_tracked | dirstate_flag_merged);

		t->mode = 0;

		t->size = dirstate_v1_from_p2;

		t->mtime = ambiguous_time;

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

		t->flags = dirstate_flag_wc_tracked;

		t->mode = 0;

		t->size = dirstate_v1_nonnormal;

		t->mtime = ambiguous_time;

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

		t->mode = 0;

		t->size = 0;

		t->mtime = 0;

		if (size == dirstate_v1_nonnormal) {

			t->flags =

			    (dirstate_flag_p1_tracked |

			     dirstate_flag_p2_tracked | dirstate_flag_merged);

		} else if (size == dirstate_v1_from_p2) {

			t->flags =

			    (dirstate_flag_p2_tracked | dirstate_flag_clean_p2);

		} else {

			t->flags = dirstate_flag_p1_tracked;

		}

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

		if (size == dirstate_v1_from_p2) {

			t->flags =

			    (dirstate_flag_wc_tracked |

			     dirstate_flag_p2_tracked | dirstate_flag_clean_p2);

			t->mode = 0;

			t->size = dirstate_v1_from_p2;

			t->mtime = ambiguous_time;

		} else if (size == dirstate_v1_nonnormal) {

			t->flags = (dirstate_flag_wc_tracked |

			            dirstate_flag_p1_tracked |

			            dirstate_flag_possibly_dirty);

			t->mode = 0;

			t->size = dirstate_v1_nonnormal;

			t->mtime = ambiguous_time;

		} else if (mtime == ambiguous_time) {

			t->flags = (dirstate_flag_wc_tracked |

			            dirstate_flag_p1_tracked |

			            dirstate_flag_possibly_dirty);

			t->mode = mode;

			t->size = size;

			t->mtime = 0;

		} else {

			t->flags = (dirstate_flag_wc_tracked |

			            dirstate_flag_p1_tracked);

			t->mode = mode;

			t->size = size;

			t->mtime = mtime;

		}

	} else if (state == ' ') {

		/* XXX Rust is using this special case, it should be clean up

		 * later. */

		t->flags = dirstate_flag_rust_special;

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

		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;

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

	            dirstate_flag_p2_tracked | dirstate_flag_merged);

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

	            dirstate_flag_clean_p2);

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

	            dirstate_flag_possibly_dirty);

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

	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)

{

	if (self->flags |= dirstate_flag_possibly_dirty) {