/*

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

	int has_meaningful_data;

	int has_meaningful_mtime;

	int mode;

	int size;

	int mtime_s;

	int mtime_ns;

	PyObject *parentfiledata;

	PyObject *fallback_exec;

	PyObject *fallback_symlink;

	static char *keywords_name[] = {

	    "wc_tracked",          "p1_tracked",           "p2_info",

	    "has_meaningful_data", "has_meaningful_mtime", "parentfiledata",

	    "fallback_exec",       "fallback_symlink",     NULL,

	};

	wc_tracked = 0;

	p1_tracked = 0;

	p2_info = 0;

	has_meaningful_mtime = 1;

	has_meaningful_data = 1;

	parentfiledata = Py_None;

	fallback_exec = Py_None;

	fallback_symlink = Py_None;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iiiiiOOO", keywords_name,

	                                 &wc_tracked, &p1_tracked, &p2_info,

	                                 &has_meaningful_data,

	                                 &has_meaningful_mtime, &parentfiledata,

	                                 &fallback_exec, &fallback_symlink)) {

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

		t->flags |= dirstate_flag_p2_info;

	}

	if (fallback_exec != Py_None) {

		t->flags |= dirstate_flag_has_fallback_exec;

		if (PyObject_IsTrue(fallback_exec)) {

			t->flags |= dirstate_flag_fallback_exec;

		}

	}

	if (fallback_symlink != Py_None) {

		t->flags |= dirstate_flag_has_fallback_symlink;

		if (PyObject_IsTrue(fallback_symlink)) {

			t->flags |= dirstate_flag_fallback_symlink;

		}

	}

	if (parentfiledata != Py_None) {

		if (!PyArg_ParseTuple(parentfiledata, "ii(ii)", &mode, &size,

		                      &mtime_s, &mtime_ns)) {

			return NULL;

		}

	} else {

		has_meaningful_data = 0;

		has_meaningful_mtime = 0;

	}

	if (has_meaningful_data) {

		t->flags |= dirstate_flag_has_meaningful_data;

		t->mode = mode;

		t->size = size;

	} else {

		t->mode = 0;

		t->size = 0;

	}

	if (has_meaningful_mtime) {

		t->mtime_s = mtime_s;

		t->mtime_ns = mtime_ns;

	} else {

		t->mtime_s = 0;

		t->mtime_ns = 0;

	}

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

{

	const int mask = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |

	                 dirstate_flag_p2_info;

	return (self->flags & mask);

}

static inline bool dirstate_item_c_added(dirstateItemObject *self)

{

	const int mask = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |

	                  dirstate_flag_p2_info);

	const int 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_info));

}

static inline bool dirstate_item_c_merged(dirstateItemObject *self)

{

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

	        (self->flags & dirstate_flag_p1_tracked) &&

	        (self->flags & dirstate_flag_p2_info));

}

static inline bool dirstate_item_c_from_p2(dirstateItemObject *self)

{

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

	        !(self->flags & dirstate_flag_p1_tracked) &&

	        (self->flags & dirstate_flag_p2_info));

}

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 bool dirstate_item_c_has_fallback_exec(dirstateItemObject *self)

{

	return (bool)self->flags & dirstate_flag_has_fallback_exec;

}

static inline bool

dirstate_item_c_has_fallback_symlink(dirstateItemObject *self)

{

	return (bool)self->flags & dirstate_flag_has_fallback_symlink;

}

static inline int dirstate_item_c_v1_mode(dirstateItemObject *self)

{

	if (self->flags & dirstate_flag_has_meaningful_data) {

		return self->mode;

	} else {

		return 0;

	}

}

static inline int dirstate_item_c_v1_size(dirstateItemObject *self)

{

	if (!(self->flags & dirstate_flag_wc_tracked) &&

	    (self->flags & dirstate_flag_p2_info)) {

		if (self->flags & dirstate_flag_p1_tracked) {

			return dirstate_v1_nonnormal;

		} else {

			return dirstate_v1_from_p2;

		}

	} else if (dirstate_item_c_removed(self)) {

		return 0;

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

		return dirstate_v1_from_p2;

	} else if (dirstate_item_c_added(self)) {

		return dirstate_v1_nonnormal;

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

		return self->size;

	} else {

		return dirstate_v1_nonnormal;

	}

}

static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self)

{

	if (dirstate_item_c_removed(self)) {

		return 0;

	           !(self->flags & dirstate_flag_p1_tracked) ||

	           !(self->flags & dirstate_flag_wc_tracked) ||

	           (self->flags & dirstate_flag_p2_info)) {

		return ambiguous_time;

	} else {

		return self->mtime_s;

	}

}

static PyObject *dirstate_item_v2_data(dirstateItemObject *self)

{

	int flags = self->flags;

	int mode = dirstate_item_c_v1_mode(self);

	if ((mode & S_IXUSR) != 0) {

		flags |= dirstate_flag_mode_exec_perm;

	} else {

		flags &= ~dirstate_flag_mode_exec_perm;

	}

	if (S_ISLNK(mode)) {

		flags |= dirstate_flag_mode_is_symlink;

	} else {

		flags &= ~dirstate_flag_mode_is_symlink;

	}

	return Py_BuildValue("iiii", flags, self->size, self->mtime_s,

	                     self->mtime_ns);

};

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 *now)

{

	int now_s;

	int now_ns;

	if (!PyArg_ParseTuple(now, "ii", &now_s, &now_ns)) {

		return NULL;

	}

	if (dirstate_item_c_v1_state(self) == 'n' && self->mtime_s == now_s) {

		Py_RETURN_TRUE;

	} else {

		Py_RETURN_FALSE;

	}

};

static PyObject *dirstate_item_mtime_likely_equal_to(dirstateItemObject *self,

                                                     PyObject *other)

{

	int other_s;

	int other_ns;

	if (!PyArg_ParseTuple(other, "ii", &other_s, &other_ns)) {

		return NULL;

	}

	    self->mtime_s == other_s &&

	    (self->mtime_ns == other_ns || self->mtime_ns == 0 ||

	     other_ns == 0)) {

		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;

	}

	t->flags = 0;

	t->mode = 0;

	t->size = 0;

	t->mtime_s = 0;

	t->mtime_ns = 0;

	if (state == 'm') {

		t->flags = (dirstate_flag_wc_tracked |

		            dirstate_flag_p1_tracked | dirstate_flag_p2_info);

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

		t->flags = dirstate_flag_wc_tracked;

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

		if (size == dirstate_v1_nonnormal) {

			t->flags =

			    dirstate_flag_p1_tracked | dirstate_flag_p2_info;

		} else if (size == dirstate_v1_from_p2) {

			t->flags = dirstate_flag_p2_info;

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

		} else if (size == dirstate_v1_nonnormal) {

			t->flags =

			    dirstate_flag_wc_tracked | dirstate_flag_p1_tracked;

		} else if (mtime == ambiguous_time) {

			t->flags = (dirstate_flag_wc_tracked |

			            dirstate_flag_p1_tracked |

			            dirstate_flag_has_meaningful_data);

			t->mode = mode;

			t->size = size;

		} else {

			t->flags = (dirstate_flag_wc_tracked |

			            dirstate_flag_p1_tracked |

			            dirstate_flag_has_meaningful_data |

			t->mode = mode;

			t->size = size;

			t->mtime_s = mtime;

		}

	} else {

		PyErr_Format(PyExc_RuntimeError,

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