This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11387

dirstate-item: move the C implementation to the same logic
ClosedPublic

Authored by marmoute on Sep 1 2021, 7:36 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG83f0e93ec34b: dirstate-item: move the C implementation to the same logic
Summary

Now that we know were we are going, we can update the C implementation.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Revision Contents
Changeset List

Diff 30193

mercurial/cext/charencode.c

while (PyDict_Next(dmap, &pos, &k, &v)) { while (PyDict_Next(dmap, &pos, &k, &v)) {
if (!dirstate_tuple_check(v)) { if (!dirstate_tuple_check(v)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"expected a dirstate tuple"); "expected a dirstate tuple");
goto quit; goto quit;
} }
tuple = (dirstateItemObject *)v; tuple = (dirstateItemObject *)v;
if (tuple->state != 'r') { if (tuple->flags | dirstate_flag_wc_tracked) {
PyObject *normed; PyObject *normed;
if (table != NULL) { if (table != NULL) {
normed = _asciitransform(k, table, normed = _asciitransform(k, table,
normcase_fallback); normcase_fallback);
} else { } else {
normed = PyObject_CallFunctionObjArgs( normed = PyObject_CallFunctionObjArgs(
normcase_fallback, k, NULL); normcase_fallback, k, NULL);
} }

mercurial/cext/dirs.c

return -1; return -1;
} }
if (only_tracked) { if (only_tracked) {
if (!dirstate_tuple_check(value)) { if (!dirstate_tuple_check(value)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"expected a dirstate tuple"); "expected a dirstate tuple");
return -1; return -1;
} }
if (((dirstateItemObject *)value)->state == 'r') if (!(((dirstateItemObject *)value)->flags &
dirstate_flag_wc_tracked))
continue; continue;
} }
if (_addpath(dirs, key) == -1) if (_addpath(dirs, key) == -1)
return -1; return -1;
} }
return 0; return 0;

mercurial/cext/parsers.c

"`merged` argument incompatible with " "`merged` argument incompatible with "
"`clean_p1`/`clean_p2`"); "`clean_p1`/`clean_p2`");
return NULL; return NULL;
} }
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->state = 'r';
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->mode = 0;
t->size = dirstate_v1_nonnormal; t->size = dirstate_v1_nonnormal;
t->mtime = ambiguous_time; t->mtime = ambiguous_time;
if (!(p1_tracked || p2_tracked || wc_tracked)) { if (parentfiledata != Py_None) {
/* 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)) { if (!PyTuple_CheckExact(parentfiledata)) {
PyErr_SetString( PyErr_SetString(
PyExc_TypeError, PyExc_TypeError,
"parentfiledata should be a Tuple or None"); "parentfiledata should be a Tuple or None");
return NULL; return NULL;
} }
t->state = 'n';
t->mode = t->mode =
(int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 0)); (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 0));
t->size = t->size =
(int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 1)); (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 1));
t->mtime = t->mtime =
(int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 2)); (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 2));
} else {
PyErr_SetString(PyExc_RuntimeError, "unreachable");
return NULL;
} }
return (PyObject *)t; return (PyObject *)t;
} }
static void dirstate_item_dealloc(PyObject *o) static void dirstate_item_dealloc(PyObject *o)
{ {
PyObject_Del(o); PyObject_Del(o);
} }
static inline bool dirstate_item_c_tracked(dirstateItemObject *self) static inline bool dirstate_item_c_tracked(dirstateItemObject *self)
{ {
return (self->state == 'a' || self->state == 'm' || self->state == 'n'); return (self->flags & dirstate_flag_wc_tracked);
} }
static inline bool dirstate_item_c_added(dirstateItemObject *self) static inline bool dirstate_item_c_added(dirstateItemObject *self)
{ {
return (self->state == 'a'); 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) static inline bool dirstate_item_c_removed(dirstateItemObject *self)
{ {
return (self->state == 'r'); 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) static inline bool dirstate_item_c_merged(dirstateItemObject *self)
{ {
return (self->state == 'm'); return ((self->flags & dirstate_flag_wc_tracked) &&
(self->flags & dirstate_flag_merged));
} }
static inline bool dirstate_item_c_merged_removed(dirstateItemObject *self) static inline bool dirstate_item_c_merged_removed(dirstateItemObject *self)
{ {
return (self->state == 'r' && self->size == dirstate_v1_nonnormal); if (!dirstate_item_c_removed(self)) {
return false;
}
return (self->flags & dirstate_flag_merged);
} }
static inline bool dirstate_item_c_from_p2(dirstateItemObject *self) static inline bool dirstate_item_c_from_p2(dirstateItemObject *self)
{ {
return (self->state == 'n' && self->size == dirstate_v1_from_p2); 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) static inline bool dirstate_item_c_from_p2_removed(dirstateItemObject *self)
{ {
return (self->state == 'r' && self->size == dirstate_v1_from_p2); 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) static inline char dirstate_item_c_v1_state(dirstateItemObject *self)
{ {
return self->state; 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) static inline int dirstate_item_c_v1_mode(dirstateItemObject *self)
{ {
return self->mode; return self->mode;
} }
static inline int dirstate_item_c_v1_size(dirstateItemObject *self) static inline int dirstate_item_c_v1_size(dirstateItemObject *self)
{ {
if (self->flags & dirstate_flag_rust_special) {
return self->size; 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) static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self)
{ {
if (self->flags & dirstate_flag_rust_special) {
return self->mtime; 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) static PyObject *dirstate_item_v1_state(dirstateItemObject *self)
{ {
char state = dirstate_item_c_v1_state(self); char state = dirstate_item_c_v1_state(self);
return PyBytes_FromStringAndSize(&state, 1); return PyBytes_FromStringAndSize(&state, 1);
}; };
static inline dirstateItemObject * static inline dirstateItemObject *
dirstate_item_from_v1_data(char state, int mode, int size, int mtime) dirstate_item_from_v1_data(char state, int mode, int size, int mtime)
{ {
dirstateItemObject *t = dirstateItemObject *t =
PyObject_New(dirstateItemObject, &dirstateItemType); PyObject_New(dirstateItemObject, &dirstateItemType);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->state = state;
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->mode = mode;
t->size = size; t->size = size;
t->mtime = mtime; t->mtime = mtime;
} else {
PyErr_Format(PyExc_RuntimeError,
"unknown state: `%c` (%d, %d, %d)", state, mode,
size, mtime, NULL);
return NULL;
}
return t; return t;
} }
/* This will never change since it's bound to V1, unlike `dirstate_item_new` */ /* This will never change since it's bound to V1, unlike `dirstate_item_new` */
static PyObject *dirstate_item_from_v1_meth(PyTypeObject *subtype, static PyObject *dirstate_item_from_v1_meth(PyTypeObject *subtype,
PyObject *args) PyObject *args)
{ {
/* We do all the initialization here and not a tp_init function because /* We do all the initialization here and not a tp_init function because
Should eventually be removed */ Should eventually be removed */
static PyObject *dirstate_item_new_added(PyTypeObject *subtype) static PyObject *dirstate_item_new_added(PyTypeObject *subtype)
{ {
dirstateItemObject *t; dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->state = 'a'; t->flags = dirstate_flag_wc_tracked;
t->mode = 0; t->mode = 0;
t->size = dirstate_v1_nonnormal; t->size = dirstate_v1_nonnormal;
t->mtime = ambiguous_time; t->mtime = ambiguous_time;
return (PyObject *)t; return (PyObject *)t;
}; };
/* constructor to help legacy API to build a new "merged" item /* constructor to help legacy API to build a new "merged" item
Should eventually be removed */ Should eventually be removed */
static PyObject *dirstate_item_new_merged(PyTypeObject *subtype) static PyObject *dirstate_item_new_merged(PyTypeObject *subtype)
{ {
dirstateItemObject *t; dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->state = 'm'; t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
dirstate_flag_p2_tracked | dirstate_flag_merged);
t->mode = 0; t->mode = 0;
t->size = dirstate_v1_from_p2; t->size = dirstate_v1_from_p2;
t->mtime = ambiguous_time; t->mtime = ambiguous_time;
return (PyObject *)t; return (PyObject *)t;
}; };
/* constructor to help legacy API to build a new "from_p2" item /* constructor to help legacy API to build a new "from_p2" item
Should eventually be removed */ Should eventually be removed */
static PyObject *dirstate_item_new_from_p2(PyTypeObject *subtype) static PyObject *dirstate_item_new_from_p2(PyTypeObject *subtype)
{ {
/* We do all the initialization here and not a tp_init function because /* We do all the initialization here and not a tp_init function because
* dirstate_item is immutable. */ * dirstate_item is immutable. */
dirstateItemObject *t; dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->state = 'n'; t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p2_tracked |
dirstate_flag_clean_p2);
t->mode = 0; t->mode = 0;
t->size = dirstate_v1_from_p2; t->size = dirstate_v1_from_p2;
t->mtime = ambiguous_time; t->mtime = ambiguous_time;
return (PyObject *)t; return (PyObject *)t;
}; };
/* constructor to help legacy API to build a new "possibly" item /* constructor to help legacy API to build a new "possibly" item
Should eventually be removed */ Should eventually be removed */
static PyObject *dirstate_item_new_possibly_dirty(PyTypeObject *subtype) static PyObject *dirstate_item_new_possibly_dirty(PyTypeObject *subtype)
{ {
/* We do all the initialization here and not a tp_init function because /* We do all the initialization here and not a tp_init function because
* dirstate_item is immutable. */ * dirstate_item is immutable. */
dirstateItemObject *t; dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->state = 'n'; t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
dirstate_flag_possibly_dirty);
t->mode = 0; t->mode = 0;
t->size = dirstate_v1_nonnormal; t->size = dirstate_v1_nonnormal;
t->mtime = ambiguous_time; t->mtime = ambiguous_time;
return (PyObject *)t; return (PyObject *)t;
}; };
/* constructor to help legacy API to build a new "normal" item /* constructor to help legacy API to build a new "normal" item
Should eventually be removed */ Should eventually be removed */
static PyObject *dirstate_item_new_normal(PyTypeObject *subtype, PyObject *args) static PyObject *dirstate_item_new_normal(PyTypeObject *subtype, PyObject *args)
{ {
/* We do all the initialization here and not a tp_init function because /* We do all the initialization here and not a tp_init function because
* dirstate_item is immutable. */ * dirstate_item is immutable. */
dirstateItemObject *t; dirstateItemObject *t;
int size, mode, mtime; int size, mode, mtime;
if (!PyArg_ParseTuple(args, "iii", &mode, &size, &mtime)) { if (!PyArg_ParseTuple(args, "iii", &mode, &size, &mtime)) {
return NULL; return NULL;
} }
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->state = 'n'; t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked);
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
t->mtime = mtime; t->mtime = mtime;
return (PyObject *)t; return (PyObject *)t;
}; };
/* This means the next status call will have to actually check its content /* This means the next status call will have to actually check its content
to make sure it is correct. */ to make sure it is correct. */
static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self) static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self)
{ {
self->mtime = ambiguous_time; if (self->flags |= dirstate_flag_possibly_dirty) {
Py_RETURN_NONE; Py_RETURN_NONE;
} }
}
static PyObject *dirstate_item_set_untracked(dirstateItemObject *self) static PyObject *dirstate_item_set_untracked(dirstateItemObject *self)
{ {
if (self->state == 'm') { self->flags &= ~dirstate_flag_wc_tracked;
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->mode = 0;
self->mtime = 0; self->mtime = 0;
self->size = 0;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyMethodDef dirstate_item_methods[] = { static PyMethodDef dirstate_item_methods[] = {
{"v1_state", (PyCFunction)dirstate_item_v1_state, METH_NOARGS, {"v1_state", (PyCFunction)dirstate_item_v1_state, METH_NOARGS,
"return a \"state\" suitable for v1 serialization"}, "return a \"state\" suitable for v1 serialization"},
{"v1_mode", (PyCFunction)dirstate_item_v1_mode, METH_NOARGS, {"v1_mode", (PyCFunction)dirstate_item_v1_mode, METH_NOARGS,
"return a \"mode\" suitable for v1 serialization"}, "return a \"mode\" suitable for v1 serialization"},
dirstateItemObject *t; dirstateItemObject *t;
if (!dirstate_tuple_check(v)) { if (!dirstate_tuple_check(v)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"expected a dirstate tuple"); "expected a dirstate tuple");
goto bail; goto bail;
} }
t = (dirstateItemObject *)v; t = (dirstateItemObject *)v;
if (t->state == 'n' && t->size == -2) { if (dirstate_item_c_from_p2(t)) {
if (PySet_Add(otherpset, fname) == -1) { if (PySet_Add(otherpset, fname) == -1) {
goto bail; goto bail;
} }
} }
if (!(t->flags & dirstate_flag_wc_tracked) ||
if (t->state == 'n' && t->mtime != -1) { !(t->flags &
continue; (dirstate_flag_p1_tracked | dirstate_flag_p2_tracked)) ||
} (t->flags &
(dirstate_flag_possibly_dirty | dirstate_flag_merged))) {
if (PySet_Add(nonnset, fname) == -1) { if (PySet_Add(nonnset, fname) == -1) {
goto bail; goto bail;
} }
} }
}
result = Py_BuildValue("(OO)", nonnset, otherpset); result = Py_BuildValue("(OO)", nonnset, otherpset);
if (result == NULL) { if (result == NULL) {
goto bail; goto bail;
} }
Py_DECREF(nonnset); Py_DECREF(nonnset);
Py_DECREF(otherpset); Py_DECREF(otherpset);
return result; return result;
if (!dirstate_tuple_check(v)) { if (!dirstate_tuple_check(v)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"expected a dirstate tuple"); "expected a dirstate tuple");
goto bail; goto bail;
} }
tuple = (dirstateItemObject *)v; tuple = (dirstateItemObject *)v;
state = tuple->state; state = dirstate_item_c_v1_state(tuple);
mode = tuple->mode; mode = dirstate_item_c_v1_mode(tuple);
size = tuple->size; size = dirstate_item_c_v1_size(tuple);
mtime = tuple->mtime; mtime = dirstate_item_c_v1_mtime(tuple);
if (state == 'n' && mtime == now) { if (state == 'n' && mtime == now) {
/* See pure/parsers.py:pack_dirstate for why we do /* See pure/parsers.py:pack_dirstate for why we do
* this. */ * this. */
mtime = -1; mtime = -1;
mtime_unset = (PyObject *)dirstate_item_from_v1_data( mtime_unset = (PyObject *)dirstate_item_from_v1_data(
state, mode, size, mtime); state, mode, size, mtime);
if (!mtime_unset) { if (!mtime_unset) {
goto bail; goto bail;

mercurial/cext/util.h

#define PY23(py2, py3) py3 #define PY23(py2, py3) py3
#else #else
#define PY23(py2, py3) py2 #define PY23(py2, py3) py2
#endif #endif
/* clang-format off */ /* clang-format off */
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
char state; char flags;
int mode; int mode;
int size; int size;
int mtime; int mtime;
} dirstateItemObject; } dirstateItemObject;
/* clang-format on */ /* clang-format on */
static const char dirstate_flag_wc_tracked = 1;
static const char dirstate_flag_p1_tracked = 1 << 1;
static const char dirstate_flag_p2_tracked = 1 << 2;
static const char dirstate_flag_possibly_dirty = 1 << 3;
static const char dirstate_flag_merged = 1 << 4;
static const char dirstate_flag_clean_p1 = 1 << 5;
static const char dirstate_flag_clean_p2 = 1 << 6;
static const char dirstate_flag_rust_special = 1 << 7;
extern PyTypeObject dirstateItemType; extern PyTypeObject dirstateItemType;
#define dirstate_tuple_check(op) (Py_TYPE(op) == &dirstateItemType) #define dirstate_tuple_check(op) (Py_TYPE(op) == &dirstateItemType)
#ifndef MIN #ifndef MIN
#define MIN(a, b) (((a) < (b)) ? (a) : (b)) #define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif #endif
/* VC9 doesn't include bool and lacks stdbool.h based on my searching */ /* VC9 doesn't include bool and lacks stdbool.h based on my searching */
#if defined(_MSC_VER) || __STDC_VERSION__ < 199901L #if defined(_MSC_VER) || __STDC_VERSION__ < 199901L