|
|
/*
|
|
|
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->flags |= dirstate_flag_has_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;
|
|
|
} else if (!(self->flags & dirstate_flag_has_mtime) ||
|
|
|
!(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);
|
|
|
#ifdef S_IXUSR
|
|
|
/* This is for platforms with an exec bit */
|
|
|
if ((mode & S_IXUSR) != 0) {
|
|
|
flags |= dirstate_flag_mode_exec_perm;
|
|
|
} else {
|
|
|
flags &= ~dirstate_flag_mode_exec_perm;
|
|
|
}
|
|
|
#else
|
|
|
flags &= ~dirstate_flag_mode_exec_perm;
|
|
|
#endif
|
|
|
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;
|
|
|
}
|
|
|
if ((self->flags & dirstate_flag_has_mtime) &&
|
|
|
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 |
|
|
|
dirstate_flag_has_mtime);
|
|
|
t->mode = mode;
|
|
|
t->size = size;
|
|
|
t->mtime_s = 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);
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_from_v2_meth(PyTypeObject *subtype,
|
|
|
PyObject *args)
|
|
|
{
|
|
|
dirstateItemObject *t =
|
|
|
PyObject_New(dirstateItemObject, &dirstateItemType);
|
|
|
if (!t) {
|
|
|
return NULL;
|
|
|
}
|
|
|
if (!PyArg_ParseTuple(args, "iiii", &t->flags, &t->size, &t->mtime_s,
|
|
|
&t->mtime_ns)) {
|
|
|
return NULL;
|
|
|
}
|
|
|
if (t->flags & dirstate_flag_expected_state_is_modified) {
|
|
|
t->flags &= ~(dirstate_flag_expected_state_is_modified |
|
|
|
dirstate_flag_has_meaningful_data |
|
|
|
dirstate_flag_has_mtime);
|
|
|
}
|
|
|
if (t->flags & dirstate_flag_mtime_second_ambiguous) {
|
|
|
/* The current code is not able to do the more subtle comparison
|
|
|
* that the MTIME_SECOND_AMBIGUOUS requires. So we ignore the
|
|
|
* mtime */
|
|
|
t->flags &= ~(dirstate_flag_mtime_second_ambiguous |
|
|
|
dirstate_flag_has_meaningful_data |
|
|
|
dirstate_flag_has_mtime);
|
|
|
}
|
|
|
t->mode = 0;
|
|
|
if (t->flags & dirstate_flag_has_meaningful_data) {
|
|
|
if (t->flags & dirstate_flag_mode_exec_perm) {
|
|
|
t->mode = 0755;
|
|
|
} else {
|
|
|
t->mode = 0644;
|
|
|
}
|
|
|
if (t->flags & dirstate_flag_mode_is_symlink) {
|
|
|
t->mode |= S_IFLNK;
|
|
|
} else {
|
|
|
t->mode |= S_IFREG;
|
|
|
}
|
|
|
}
|
|
|
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->flags &= ~dirstate_flag_has_mtime;
|
|
|
Py_RETURN_NONE;
|
|
|
}
|
|
|
|
|
|
/* See docstring of the python implementation for details */
|
|
|
static PyObject *dirstate_item_set_clean(dirstateItemObject *self,
|
|
|
PyObject *args)
|
|
|
{
|
|
|
int size, mode, mtime_s, mtime_ns;
|
|
|
if (!PyArg_ParseTuple(args, "ii(ii)", &mode, &size, &mtime_s,
|
|
|
&mtime_ns)) {
|
|
|
return NULL;
|
|
|
}
|
|
|
self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
|
|
|
dirstate_flag_has_meaningful_data |
|
|
|
dirstate_flag_has_mtime;
|
|
|
self->mode = mode;
|
|
|
self->size = size;
|
|
|
self->mtime_s = mtime_s;
|
|
|
self->mtime_ns = mtime_ns;
|
|
|
Py_RETURN_NONE;
|
|
|
}
|
|
|
|
|
|
static PyObject *dirstate_item_set_tracked(dirstateItemObject *self)
|
|
|
{
|
|
|
self->flags |= dirstate_flag_wc_tracked;
|
|
|
self->flags &= ~dirstate_flag_has_mtime;
|
|
|
Py_RETURN_NONE;
|
|
|
}
|
|
|
|
|
|
static PyObject *dirstate_item_set_untracked(dirstateItemObject *self)
|
|
|
{
|
|
|
self->flags &= ~dirstate_flag_wc_tracked;
|
|
|
self->mode = 0;
|
|
|
self->size = 0;
|
|
|
self->mtime_s = 0;
|
|
|
self->mtime_ns = 0;
|
|
|
Py_RETURN_NONE;
|
|
|
}
|
|
|
|
|
|
static PyObject *dirstate_item_drop_merge_data(dirstateItemObject *self)
|
|
|
{
|
|
|
if (self->flags & dirstate_flag_p2_info) {
|
|
|
self->flags &= ~(dirstate_flag_p2_info |
|
|
|
dirstate_flag_has_meaningful_data |
|
|
|
dirstate_flag_has_mtime);
|
|
|
self->mode = 0;
|
|
|
self->size = 0;
|
|
|
self->mtime_s = 0;
|
|
|
self->mtime_ns = 0;
|
|
|
}
|
|
|
Py_RETURN_NONE;
|
|
|
}
|
|
|
static PyMethodDef dirstate_item_methods[] = {
|
|
|
{"v2_data", (PyCFunction)dirstate_item_v2_data, METH_NOARGS,
|
|
|
"return data suitable for v2 serialization"},
|
|
|
{"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"},
|
|
|
{"mtime_likely_equal_to", (PyCFunction)dirstate_item_mtime_likely_equal_to,
|
|
|
METH_O, "True if the stored mtime is likely equal to the given mtime"},
|
|
|
{"from_v1_data", (PyCFunction)dirstate_item_from_v1_meth,
|
|
|
METH_VARARGS | METH_CLASS, "build a new DirstateItem object from V1 data"},
|
|
|
{"from_v2_data", (PyCFunction)dirstate_item_from_v2_meth,
|
|
|
METH_VARARGS | METH_CLASS, "build a new DirstateItem object from V2 data"},
|
|
|
{"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty,
|
|
|
METH_NOARGS, "mark a file as \"possibly dirty\""},
|
|
|
{"set_clean", (PyCFunction)dirstate_item_set_clean, METH_VARARGS,
|
|
|
"mark a file as \"clean\""},
|
|
|
{"set_tracked", (PyCFunction)dirstate_item_set_tracked, METH_NOARGS,
|
|
|
"mark a file as \"tracked\""},
|
|
|
{"set_untracked", (PyCFunction)dirstate_item_set_untracked, METH_NOARGS,
|
|
|
"mark a file as \"untracked\""},
|
|
|
{"drop_merge_data", (PyCFunction)dirstate_item_drop_merge_data, METH_NOARGS,
|
|
|
"remove all \"merge-only\" from a DirstateItem"},
|
|
|
{NULL} /* Sentinel */
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_mode(dirstateItemObject *self)
|
|
|
{
|
|
|
return PyInt_FromLong(dirstate_item_c_v1_mode(self));
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_size(dirstateItemObject *self)
|
|
|
{
|
|
|
return PyInt_FromLong(dirstate_item_c_v1_size(self));
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_mtime(dirstateItemObject *self)
|
|
|
{
|
|
|
return PyInt_FromLong(dirstate_item_c_v1_mtime(self));
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_state(dirstateItemObject *self)
|
|
|
{
|
|
|
char state = dirstate_item_c_v1_state(self);
|
|
|
return PyBytes_FromStringAndSize(&state, 1);
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_has_fallback_exec(dirstateItemObject *self)
|
|
|
{
|
|
|
if (dirstate_item_c_has_fallback_exec(self)) {
|
|
|
Py_RETURN_TRUE;
|
|
|
} else {
|
|
|
Py_RETURN_FALSE;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_fallback_exec(dirstateItemObject *self)
|
|
|
{
|
|
|
if (dirstate_item_c_has_fallback_exec(self)) {
|
|
|
if (self->flags & dirstate_flag_fallback_exec) {
|
|
|
Py_RETURN_TRUE;
|
|
|
} else {
|
|
|
Py_RETURN_FALSE;
|
|
|
}
|
|
|
} else {
|
|
|
Py_RETURN_NONE;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
static int dirstate_item_set_fallback_exec(dirstateItemObject *self,
|
|
|
PyObject *value)
|
|
|
{
|
|
|
if ((value == Py_None) || (value == NULL)) {
|
|
|
self->flags &= ~dirstate_flag_has_fallback_exec;
|
|
|
} else {
|
|
|
self->flags |= dirstate_flag_has_fallback_exec;
|
|
|
if (PyObject_IsTrue(value)) {
|
|
|
self->flags |= dirstate_flag_fallback_exec;
|
|
|
} else {
|
|
|
self->flags &= ~dirstate_flag_fallback_exec;
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
};
|
|
|
|
|
|
static PyObject *
|
|
|
dirstate_item_get_has_fallback_symlink(dirstateItemObject *self)
|
|
|
{
|
|
|
if (dirstate_item_c_has_fallback_symlink(self)) {
|
|
|
Py_RETURN_TRUE;
|
|
|
} else {
|
|
|
Py_RETURN_FALSE;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_fallback_symlink(dirstateItemObject *self)
|
|
|
{
|
|
|
if (dirstate_item_c_has_fallback_symlink(self)) {
|
|
|
if (self->flags & dirstate_flag_fallback_symlink) {
|
|
|
Py_RETURN_TRUE;
|
|
|
} else {
|
|
|
Py_RETURN_FALSE;
|
|
|
}
|
|
|
} else {
|
|
|
Py_RETURN_NONE;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
static int dirstate_item_set_fallback_symlink(dirstateItemObject *self,
|
|
|
PyObject *value)
|
|
|
{
|
|
|
if ((value == Py_None) || (value == NULL)) {
|
|
|
self->flags &= ~dirstate_flag_has_fallback_symlink;
|
|
|
} else {
|
|
|
self->flags |= dirstate_flag_has_fallback_symlink;
|
|
|
if (PyObject_IsTrue(value)) {
|
|
|
self->flags |= dirstate_flag_fallback_symlink;
|
|
|
} else {
|
|
|
self->flags &= ~dirstate_flag_fallback_symlink;
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_tracked(dirstateItemObject *self)
|
|
|
{
|
|
|
if (dirstate_item_c_tracked(self)) {
|
|
|
Py_RETURN_TRUE;
|
|
|
} else {
|
|
|
Py_RETURN_FALSE;
|
|
|
}
|
|
|
};
|
|
|
static PyObject *dirstate_item_get_p1_tracked(dirstateItemObject *self)
|
|
|
{
|
|
|
if (self->flags & dirstate_flag_p1_tracked) {
|
|
|
Py_RETURN_TRUE;
|
|
|
} else {
|
|
|
Py_RETURN_FALSE;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_added(dirstateItemObject *self)
|
|
|
{
|
|
|
if (dirstate_item_c_added(self)) {
|
|
|
Py_RETURN_TRUE;
|
|
|
} else {
|
|
|
Py_RETURN_FALSE;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_p2_info(dirstateItemObject *self)
|
|
|
{
|
|
|
if (self->flags & dirstate_flag_wc_tracked &&
|
|
|
self->flags & dirstate_flag_p2_info) {
|
|
|
Py_RETURN_TRUE;
|
|
|
} else {
|
|
|
Py_RETURN_FALSE;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_merged(dirstateItemObject *self)
|
|
|
{
|
|
|
if (dirstate_item_c_merged(self)) {
|
|
|
Py_RETURN_TRUE;
|
|
|
} else {
|
|
|
Py_RETURN_FALSE;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_from_p2(dirstateItemObject *self)
|
|
|
{
|
|
|
if (dirstate_item_c_from_p2(self)) {
|
|
|
Py_RETURN_TRUE;
|
|
|
} else {
|
|
|
Py_RETURN_FALSE;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_maybe_clean(dirstateItemObject *self)
|
|
|
{
|
|
|
if (!(self->flags & dirstate_flag_wc_tracked)) {
|
|
|
Py_RETURN_FALSE;
|
|
|
} else if (!(self->flags & dirstate_flag_p1_tracked)) {
|
|
|
Py_RETURN_FALSE;
|
|
|
} else if (self->flags & dirstate_flag_p2_info) {
|
|
|
Py_RETURN_FALSE;
|
|
|
} else {
|
|
|
Py_RETURN_TRUE;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_any_tracked(dirstateItemObject *self)
|
|
|
{
|
|
|
if (dirstate_item_c_any_tracked(self)) {
|
|
|
Py_RETURN_TRUE;
|
|
|
} else {
|
|
|
Py_RETURN_FALSE;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
static PyObject *dirstate_item_get_removed(dirstateItemObject *self)
|
|
|
{
|
|
|
if (dirstate_item_c_removed(self)) {
|
|
|
Py_RETURN_TRUE;
|
|
|
} else {
|
|
|
Py_RETURN_FALSE;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
static PyGetSetDef dirstate_item_getset[] = {
|
|
|
{"mode", (getter)dirstate_item_get_mode, NULL, "mode", NULL},
|
|
|
{"size", (getter)dirstate_item_get_size, NULL, "size", NULL},
|
|
|
{"mtime", (getter)dirstate_item_get_mtime, NULL, "mtime", NULL},
|
|
|
{"state", (getter)dirstate_item_get_state, NULL, "state", NULL},
|
|
|
{"has_fallback_exec", (getter)dirstate_item_get_has_fallback_exec, NULL,
|
|
|
"has_fallback_exec", NULL},
|
|
|
{"fallback_exec", (getter)dirstate_item_get_fallback_exec,
|
|
|
(setter)dirstate_item_set_fallback_exec, "fallback_exec", NULL},
|
|
|
{"has_fallback_symlink", (getter)dirstate_item_get_has_fallback_symlink,
|
|
|
NULL, "has_fallback_symlink", NULL},
|
|
|
{"fallback_symlink", (getter)dirstate_item_get_fallback_symlink,
|
|
|
(setter)dirstate_item_set_fallback_symlink, "fallback_symlink", NULL},
|
|
|
{"tracked", (getter)dirstate_item_get_tracked, NULL, "tracked", NULL},
|
|
|
{"p1_tracked", (getter)dirstate_item_get_p1_tracked, NULL, "p1_tracked",
|
|
|
NULL},
|
|
|
{"added", (getter)dirstate_item_get_added, NULL, "added", NULL},
|
|
|
{"p2_info", (getter)dirstate_item_get_p2_info, NULL, "p2_info", NULL},
|
|
|
{"merged", (getter)dirstate_item_get_merged, NULL, "merged", NULL},
|
|
|
{"from_p2", (getter)dirstate_item_get_from_p2, NULL, "from_p2", NULL},
|
|
|
{"maybe_clean", (getter)dirstate_item_get_maybe_clean, NULL, "maybe_clean",
|
|
|
NULL},
|
|
|
{"any_tracked", (getter)dirstate_item_get_any_tracked, NULL, "any_tracked",
|
|
|
NULL},
|
|
|
{"removed", (getter)dirstate_item_get_removed, NULL, "removed", NULL},
|
|
|
{NULL} /* Sentinel */
|
|
|
};
|
|
|
|
|
|
PyTypeObject dirstateItemType = {
|
|
|
PyVarObject_HEAD_INIT(NULL, 0) /* header */
|
|
|
"dirstate_tuple", /* tp_name */
|
|
|
sizeof(dirstateItemObject), /* tp_basicsize */
|
|
|
0, /* tp_itemsize */
|
|
|
(destructor)dirstate_item_dealloc, /* tp_dealloc */
|
|
|
0, /* tp_print */
|
|
|
0, /* tp_getattr */
|
|
|
0, /* tp_setattr */
|
|
|
0, /* tp_compare */
|
|
|
0, /* tp_repr */
|
|
|
0, /* tp_as_number */
|
|
|
0, /* tp_as_sequence */
|
|
|
0, /* tp_as_mapping */
|
|
|
0, /* tp_hash */
|
|
|
0, /* tp_call */
|
|
|
0, /* tp_str */
|
|
|
0, /* tp_getattro */
|
|
|
0, /* tp_setattro */
|
|
|
0, /* tp_as_buffer */
|
|
|
Py_TPFLAGS_DEFAULT, /* tp_flags */
|
|
|
"dirstate tuple", /* tp_doc */
|
|
|
0, /* tp_traverse */
|
|
|
0, /* tp_clear */
|
|
|
0, /* tp_richcompare */
|
|
|
0, /* tp_weaklistoffset */
|
|
|
0, /* tp_iter */
|
|
|
0, /* tp_iternext */
|
|
|
dirstate_item_methods, /* tp_methods */
|
|
|
0, /* tp_members */
|
|
|
dirstate_item_getset, /* tp_getset */
|
|
|
0, /* tp_base */
|
|
|
0, /* tp_dict */
|
|
|
0, /* tp_descr_get */
|
|
|
0, /* tp_descr_set */
|
|
|
0, /* tp_dictoffset */
|
|
|
0, /* tp_init */
|
|
|
0, /* tp_alloc */
|
|
|
dirstate_item_new, /* tp_new */
|
|
|
};
|
|
|
|
|
|
static PyObject *parse_dirstate(PyObject *self, PyObject *args)
|
|
|
{
|
|
|
PyObject *dmap, *cmap, *parents = NULL, *ret = NULL;
|
|
|
PyObject *fname = NULL, *cname = NULL, *entry = NULL;
|
|
|
char state, *cur, *str, *cpos;
|
|
|
int mode, size, mtime;
|
|
|
unsigned int flen, pos = 40;
|
|
|
Py_ssize_t len = 40;
|
|
|
Py_ssize_t readlen;
|
|
|
|
|
|
if (!PyArg_ParseTuple(
|
|
|
args, PY23("O!O!s#:parse_dirstate", "O!O!y#:parse_dirstate"),
|
|
|
&PyDict_Type, &dmap, &PyDict_Type, &cmap, &str, &readlen)) {
|
|
|
goto quit;
|
|
|
}
|
|
|
|
|
|
len = readlen;
|
|
|
|
|
|
/* read parents */
|
|
|
if (len < 40) {
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
"too little data for parents");
|
|
|
goto quit;
|
|
|
}
|
|
|
|
|
|
parents = Py_BuildValue(PY23("s#s#", "y#y#"), str, (Py_ssize_t)20,
|
|
|
str + 20, (Py_ssize_t)20);
|
|
|
if (!parents) {
|
|
|
goto quit;
|
|
|
}
|
|
|
|
|
|
/* read filenames */
|
|
|
while (pos >= 40 && pos < len) {
|
|
|
if (pos + 17 > len) {
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
"overflow in dirstate");
|
|
|
goto quit;
|
|
|
}
|
|
|
cur = str + pos;
|
|
|
/* unpack header */
|
|
|
state = *cur;
|
|
|
mode = getbe32(cur + 1);
|
|
|
size = getbe32(cur + 5);
|
|
|
mtime = getbe32(cur + 9);
|
|
|
flen = getbe32(cur + 13);
|
|
|
pos += 17;
|
|
|
cur += 17;
|
|
|
if (flen > len - pos) {
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
"overflow in dirstate");
|
|
|
goto quit;
|
|
|
}
|
|
|
|
|
|
entry = (PyObject *)dirstate_item_from_v1_data(state, mode,
|
|
|
size, mtime);
|
|
|
if (!entry)
|
|
|
goto quit;
|
|
|
cpos = memchr(cur, 0, flen);
|
|
|
if (cpos) {
|
|
|
fname = PyBytes_FromStringAndSize(cur, cpos - cur);
|
|
|
cname = PyBytes_FromStringAndSize(
|
|
|
cpos + 1, flen - (cpos - cur) - 1);
|
|
|
if (!fname || !cname ||
|
|
|
PyDict_SetItem(cmap, fname, cname) == -1 ||
|
|
|
PyDict_SetItem(dmap, fname, entry) == -1) {
|
|
|
goto quit;
|
|
|
}
|
|
|
Py_DECREF(cname);
|
|
|
} else {
|
|
|
fname = PyBytes_FromStringAndSize(cur, flen);
|
|
|
if (!fname ||
|
|
|
PyDict_SetItem(dmap, fname, entry) == -1) {
|
|
|
goto quit;
|
|
|
}
|
|
|
}
|
|
|
Py_DECREF(fname);
|
|
|
Py_DECREF(entry);
|
|
|
fname = cname = entry = NULL;
|
|
|
pos += flen;
|
|
|
}
|
|
|
|
|
|
ret = parents;
|
|
|
Py_INCREF(ret);
|
|
|
quit:
|
|
|
Py_XDECREF(fname);
|
|
|
Py_XDECREF(cname);
|
|
|
Py_XDECREF(entry);
|
|
|
Py_XDECREF(parents);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Efficiently pack a dirstate object into its on-disk format.
|
|
|
*/
|
|
|
static PyObject *pack_dirstate(PyObject *self, PyObject *args)
|
|
|
{
|
|
|
PyObject *packobj = NULL;
|
|
|
PyObject *map, *copymap, *pl, *mtime_unset = NULL;
|
|
|
Py_ssize_t nbytes, pos, l;
|
|
|
PyObject *k, *v = NULL, *pn;
|
|
|
char *p, *s;
|
|
|
int now_s;
|
|
|
int now_ns;
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, "O!O!O!(ii):pack_dirstate", &PyDict_Type,
|
|
|
&map, &PyDict_Type, ©map, &PyTuple_Type, &pl,
|
|
|
&now_s, &now_ns)) {
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
if (PyTuple_Size(pl) != 2) {
|
|
|
PyErr_SetString(PyExc_TypeError, "expected 2-element tuple");
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
/* Figure out how much we need to allocate. */
|
|
|
for (nbytes = 40, pos = 0; PyDict_Next(map, &pos, &k, &v);) {
|
|
|
PyObject *c;
|
|
|
if (!PyBytes_Check(k)) {
|
|
|
PyErr_SetString(PyExc_TypeError, "expected string key");
|
|
|
goto bail;
|
|
|
}
|
|
|
nbytes += PyBytes_GET_SIZE(k) + 17;
|
|
|
c = PyDict_GetItem(copymap, k);
|
|
|
if (c) {
|
|
|
if (!PyBytes_Check(c)) {
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
"expected string key");
|
|
|
goto bail;
|
|
|
}
|
|
|
nbytes += PyBytes_GET_SIZE(c) + 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
packobj = PyBytes_FromStringAndSize(NULL, nbytes);
|
|
|
if (packobj == NULL) {
|
|
|
goto bail;
|
|
|
}
|
|
|
|
|
|
p = PyBytes_AS_STRING(packobj);
|
|
|
|
|
|
pn = PyTuple_GET_ITEM(pl, 0);
|
|
|
if (PyBytes_AsStringAndSize(pn, &s, &l) == -1 || l != 20) {
|
|
|
PyErr_SetString(PyExc_TypeError, "expected a 20-byte hash");
|
|
|
goto bail;
|
|
|
}
|
|
|
memcpy(p, s, l);
|
|
|
p += 20;
|
|
|
pn = PyTuple_GET_ITEM(pl, 1);
|
|
|
if (PyBytes_AsStringAndSize(pn, &s, &l) == -1 || l != 20) {
|
|
|
PyErr_SetString(PyExc_TypeError, "expected a 20-byte hash");
|
|
|
goto bail;
|
|
|
}
|
|
|
memcpy(p, s, l);
|
|
|
p += 20;
|
|
|
|
|
|
for (pos = 0; PyDict_Next(map, &pos, &k, &v);) {
|
|
|
dirstateItemObject *tuple;
|
|
|
char state;
|
|
|
int mode, size, mtime;
|
|
|
Py_ssize_t len, l;
|
|
|
PyObject *o;
|
|
|
char *t;
|
|
|
|
|
|
if (!dirstate_tuple_check(v)) {
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
"expected a dirstate tuple");
|
|
|
goto bail;
|
|
|
}
|
|
|
tuple = (dirstateItemObject *)v;
|
|
|
|
|
|
state = dirstate_item_c_v1_state(tuple);
|
|
|
mode = dirstate_item_c_v1_mode(tuple);
|
|
|
size = dirstate_item_c_v1_size(tuple);
|
|
|
mtime = dirstate_item_c_v1_mtime(tuple);
|
|
|
if (state == 'n' && tuple->mtime_s == now_s) {
|
|
|
/* See pure/parsers.py:pack_dirstate for why we do
|
|
|
* this. */
|
|
|
mtime = -1;
|
|
|
mtime_unset = (PyObject *)dirstate_item_from_v1_data(
|
|
|
state, mode, size, mtime);
|
|
|
if (!mtime_unset) {
|
|
|
goto bail;
|
|
|
}
|
|
|
if (PyDict_SetItem(map, k, mtime_unset) == -1) {
|
|
|
goto bail;
|
|
|
}
|
|
|
Py_DECREF(mtime_unset);
|
|
|
mtime_unset = NULL;
|
|
|
}
|
|
|
*p++ = state;
|
|
|
putbe32((uint32_t)mode, p);
|
|
|
putbe32((uint32_t)size, p + 4);
|
|
|
putbe32((uint32_t)mtime, p + 8);
|
|
|
t = p + 12;
|
|
|
p += 16;
|
|
|
len = PyBytes_GET_SIZE(k);
|
|
|
memcpy(p, PyBytes_AS_STRING(k), len);
|
|
|
p += len;
|
|
|
o = PyDict_GetItem(copymap, k);
|
|
|
if (o) {
|
|
|
*p++ = '\0';
|
|
|
l = PyBytes_GET_SIZE(o);
|
|
|
memcpy(p, PyBytes_AS_STRING(o), l);
|
|
|
p += l;
|
|
|
len += l + 1;
|
|
|
}
|
|
|
putbe32((uint32_t)len, t);
|
|
|
}
|
|
|
|
|
|
pos = p - PyBytes_AS_STRING(packobj);
|
|
|
if (pos != nbytes) {
|
|
|
PyErr_Format(PyExc_SystemError, "bad dirstate size: %ld != %ld",
|
|
|
(long)pos, (long)nbytes);
|
|
|
goto bail;
|
|
|
}
|
|
|
|
|
|
return packobj;
|
|
|
bail:
|
|
|
Py_XDECREF(mtime_unset);
|
|
|
Py_XDECREF(packobj);
|
|
|
Py_XDECREF(v);
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
#define BUMPED_FIX 1
|
|
|
#define USING_SHA_256 2
|
|
|
#define FM1_HEADER_SIZE (4 + 8 + 2 + 2 + 1 + 1 + 1)
|
|
|
|
|
|
static PyObject *readshas(const char *source, unsigned char num,
|
|
|
Py_ssize_t hashwidth)
|
|
|
{
|
|
|
int i;
|
|
|
PyObject *list = PyTuple_New(num);
|
|
|
if (list == NULL) {
|
|
|
return NULL;
|
|
|
}
|
|
|
for (i = 0; i < num; i++) {
|
|
|
PyObject *hash = PyBytes_FromStringAndSize(source, hashwidth);
|
|
|
if (hash == NULL) {
|
|
|
Py_DECREF(list);
|
|
|
return NULL;
|
|
|
}
|
|
|
PyTuple_SET_ITEM(list, i, hash);
|
|
|
source += hashwidth;
|
|
|
}
|
|
|
return list;
|
|
|
}
|
|
|
|
|
|
static PyObject *fm1readmarker(const char *databegin, const char *dataend,
|
|
|
uint32_t *msize)
|
|
|
{
|
|
|
const char *data = databegin;
|
|
|
const char *meta;
|
|
|
|
|
|
double mtime;
|
|
|
int16_t tz;
|
|
|
uint16_t flags;
|
|
|
unsigned char nsuccs, nparents, nmetadata;
|
|
|
Py_ssize_t hashwidth = 20;
|
|
|
|
|
|
PyObject *prec = NULL, *parents = NULL, *succs = NULL;
|
|
|
PyObject *metadata = NULL, *ret = NULL;
|
|
|
int i;
|
|
|
|
|
|
if (data + FM1_HEADER_SIZE > dataend) {
|
|
|
goto overflow;
|
|
|
}
|
|
|
|
|
|
*msize = getbe32(data);
|
|
|
data += 4;
|
|
|
mtime = getbefloat64(data);
|
|
|
data += 8;
|
|
|
tz = getbeint16(data);
|
|
|
data += 2;
|
|
|
flags = getbeuint16(data);
|
|
|
data += 2;
|
|
|
|
|
|
if (flags & USING_SHA_256) {
|
|
|
hashwidth = 32;
|
|
|
}
|
|
|
|
|
|
nsuccs = (unsigned char)(*data++);
|
|
|
nparents = (unsigned char)(*data++);
|
|
|
nmetadata = (unsigned char)(*data++);
|
|
|
|
|
|
if (databegin + *msize > dataend) {
|
|
|
goto overflow;
|
|
|
}
|
|
|
dataend = databegin + *msize; /* narrow down to marker size */
|
|
|
|
|
|
if (data + hashwidth > dataend) {
|
|
|
goto overflow;
|
|
|
}
|
|
|
prec = PyBytes_FromStringAndSize(data, hashwidth);
|
|
|
data += hashwidth;
|
|
|
if (prec == NULL) {
|
|
|
goto bail;
|
|
|
}
|
|
|
|
|
|
if (data + nsuccs * hashwidth > dataend) {
|
|
|
goto overflow;
|
|
|
}
|
|
|
succs = readshas(data, nsuccs, hashwidth);
|
|
|
if (succs == NULL) {
|
|
|
goto bail;
|
|
|
}
|
|
|
data += nsuccs * hashwidth;
|
|
|
|
|
|
if (nparents == 1 || nparents == 2) {
|
|
|
if (data + nparents * hashwidth > dataend) {
|
|
|
goto overflow;
|
|
|
}
|
|
|
parents = readshas(data, nparents, hashwidth);
|
|
|
if (parents == NULL) {
|
|
|
goto bail;
|
|
|
}
|
|
|
data += nparents * hashwidth;
|
|
|
} else {
|
|
|
parents = Py_None;
|
|
|
Py_INCREF(parents);
|
|
|
}
|
|
|
|
|
|
if (data + 2 * nmetadata > dataend) {
|
|
|
goto overflow;
|
|
|
}
|
|
|
meta = data + (2 * nmetadata);
|
|
|
metadata = PyTuple_New(nmetadata);
|
|
|
if (metadata == NULL) {
|
|
|
goto bail;
|
|
|
}
|
|
|
for (i = 0; i < nmetadata; i++) {
|
|
|
PyObject *tmp, *left = NULL, *right = NULL;
|
|
|
Py_ssize_t leftsize = (unsigned char)(*data++);
|
|
|
Py_ssize_t rightsize = (unsigned char)(*data++);
|
|
|
if (meta + leftsize + rightsize > dataend) {
|
|
|
goto overflow;
|
|
|
}
|
|
|
left = PyBytes_FromStringAndSize(meta, leftsize);
|
|
|
meta += leftsize;
|
|
|
right = PyBytes_FromStringAndSize(meta, rightsize);
|
|
|
meta += rightsize;
|
|
|
tmp = PyTuple_New(2);
|
|
|
if (!left || !right || !tmp) {
|
|
|
Py_XDECREF(left);
|
|
|
Py_XDECREF(right);
|
|
|
Py_XDECREF(tmp);
|
|
|
goto bail;
|
|
|
}
|
|
|
PyTuple_SET_ITEM(tmp, 0, left);
|
|
|
PyTuple_SET_ITEM(tmp, 1, right);
|
|
|
PyTuple_SET_ITEM(metadata, i, tmp);
|
|
|
}
|
|
|
ret = Py_BuildValue("(OOHO(di)O)", prec, succs, flags, metadata, mtime,
|
|
|
(int)tz * 60, parents);
|
|
|
goto bail; /* return successfully */
|
|
|
|
|
|
overflow:
|
|
|
PyErr_SetString(PyExc_ValueError, "overflow in obsstore");
|
|
|
bail:
|
|
|
Py_XDECREF(prec);
|
|
|
Py_XDECREF(succs);
|
|
|
Py_XDECREF(metadata);
|
|
|
Py_XDECREF(parents);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
static PyObject *fm1readmarkers(PyObject *self, PyObject *args)
|
|
|
{
|
|
|
const char *data, *dataend;
|
|
|
Py_ssize_t datalen, offset, stop;
|
|
|
PyObject *markers = NULL;
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, PY23("s#nn", "y#nn"), &data, &datalen,
|
|
|
&offset, &stop)) {
|
|
|
return NULL;
|
|
|
}
|
|
|
if (offset < 0) {
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
"invalid negative offset in fm1readmarkers");
|
|
|
return NULL;
|
|
|
}
|
|
|
if (stop > datalen) {
|
|
|
PyErr_SetString(
|
|
|
PyExc_ValueError,
|
|
|
"stop longer than data length in fm1readmarkers");
|
|
|
return NULL;
|
|
|
}
|
|
|
dataend = data + datalen;
|
|
|
data += offset;
|
|
|
markers = PyList_New(0);
|
|
|
if (!markers) {
|
|
|
return NULL;
|
|
|
}
|
|
|
while (offset < stop) {
|
|
|
uint32_t msize;
|
|
|
int error;
|
|
|
PyObject *record = fm1readmarker(data, dataend, &msize);
|
|
|
if (!record) {
|
|
|
goto bail;
|
|
|
}
|
|
|
error = PyList_Append(markers, record);
|
|
|
Py_DECREF(record);
|
|
|
if (error) {
|
|
|
goto bail;
|
|
|
}
|
|
|
data += msize;
|
|
|
offset += msize;
|
|
|
}
|
|
|
return markers;
|
|
|
bail:
|
|
|
Py_DECREF(markers);
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
static char parsers_doc[] = "Efficient content parsing.";
|
|
|
|
|
|
PyObject *encodedir(PyObject *self, PyObject *args);
|
|
|
PyObject *pathencode(PyObject *self, PyObject *args);
|
|
|
PyObject *lowerencode(PyObject *self, PyObject *args);
|
|
|
PyObject *parse_index2(PyObject *self, PyObject *args, PyObject *kwargs);
|
|
|
|
|
|
static PyMethodDef methods[] = {
|
|
|
{"pack_dirstate", pack_dirstate, METH_VARARGS, "pack a dirstate\n"},
|
|
|
{"parse_dirstate", parse_dirstate, METH_VARARGS, "parse a dirstate\n"},
|
|
|
{"parse_index2", (PyCFunction)parse_index2, METH_VARARGS | METH_KEYWORDS,
|
|
|
"parse a revlog index\n"},
|
|
|
{"isasciistr", isasciistr, METH_VARARGS, "check if an ASCII string\n"},
|
|
|
{"asciilower", asciilower, METH_VARARGS, "lowercase an ASCII string\n"},
|
|
|
{"asciiupper", asciiupper, METH_VARARGS, "uppercase an ASCII string\n"},
|
|
|
{"dict_new_presized", dict_new_presized, METH_VARARGS,
|
|
|
"construct a dict with an expected size\n"},
|
|
|
{"make_file_foldmap", make_file_foldmap, METH_VARARGS,
|
|
|
"make file foldmap\n"},
|
|
|
{"jsonescapeu8fast", jsonescapeu8fast, METH_VARARGS,
|
|
|
"escape a UTF-8 byte string to JSON (fast path)\n"},
|
|
|
{"encodedir", encodedir, METH_VARARGS, "encodedir a path\n"},
|
|
|
{"pathencode", pathencode, METH_VARARGS, "fncache-encode a path\n"},
|
|
|
{"lowerencode", lowerencode, METH_VARARGS, "lower-encode a path\n"},
|
|
|
{"fm1readmarkers", fm1readmarkers, METH_VARARGS,
|
|
|
"parse v1 obsolete markers\n"},
|
|
|
{NULL, NULL}};
|
|
|
|
|
|
void dirs_module_init(PyObject *mod);
|
|
|
void manifest_module_init(PyObject *mod);
|
|
|
void revlog_module_init(PyObject *mod);
|
|
|
|
|
|
static const int version = 20;
|
|
|
|
|
|
static void module_init(PyObject *mod)
|
|
|
{
|
|
|
PyModule_AddIntConstant(mod, "version", version);
|
|
|
|
|
|
/* This module constant has two purposes. First, it lets us unit test
|
|
|
* the ImportError raised without hard-coding any error text. This
|
|
|
* means we can change the text in the future without breaking tests,
|
|
|
* even across changesets without a recompile. Second, its presence
|
|
|
* can be used to determine whether the version-checking logic is
|
|
|
* present, which also helps in testing across changesets without a
|
|
|
* recompile. Note that this means the pure-Python version of parsers
|
|
|
* should not have this module constant. */
|
|
|
PyModule_AddStringConstant(mod, "versionerrortext", versionerrortext);
|
|
|
|
|
|
dirs_module_init(mod);
|
|
|
manifest_module_init(mod);
|
|
|
revlog_module_init(mod);
|
|
|
|
|
|
if (PyType_Ready(&dirstateItemType) < 0) {
|
|
|
return;
|
|
|
}
|
|
|
Py_INCREF(&dirstateItemType);
|
|
|
PyModule_AddObject(mod, "DirstateItem", (PyObject *)&dirstateItemType);
|
|
|
}
|
|
|
|
|
|
static int check_python_version(void)
|
|
|
{
|
|
|
PyObject *sys = PyImport_ImportModule("sys"), *ver;
|
|
|
long hexversion;
|
|
|
if (!sys) {
|
|
|
return -1;
|
|
|
}
|
|
|
ver = PyObject_GetAttrString(sys, "hexversion");
|
|
|
Py_DECREF(sys);
|
|
|
if (!ver) {
|
|
|
return -1;
|
|
|
}
|
|
|
hexversion = PyInt_AsLong(ver);
|
|
|
Py_DECREF(ver);
|
|
|
/* sys.hexversion is a 32-bit number by default, so the -1 case
|
|
|
* should only occur in unusual circumstances (e.g. if sys.hexversion
|
|
|
* is manually set to an invalid value). */
|
|
|
if ((hexversion == -1) || (hexversion >> 16 != PY_VERSION_HEX >> 16)) {
|
|
|
PyErr_Format(PyExc_ImportError,
|
|
|
"%s: The Mercurial extension "
|
|
|
"modules were compiled with Python " PY_VERSION
|
|
|
", but "
|
|
|
"Mercurial is currently using Python with "
|
|
|
"sys.hexversion=%ld: "
|
|
|
"Python %s\n at: %s",
|
|
|
versionerrortext, hexversion, Py_GetVersion(),
|
|
|
Py_GetProgramFullPath());
|
|
|
return -1;
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
#ifdef IS_PY3K
|
|
|
static struct PyModuleDef parsers_module = {PyModuleDef_HEAD_INIT, "parsers",
|
|
|
parsers_doc, -1, methods};
|
|
|
|
|
|
PyMODINIT_FUNC PyInit_parsers(void)
|
|
|
{
|
|
|
PyObject *mod;
|
|
|
|
|
|
if (check_python_version() == -1)
|
|
|
return NULL;
|
|
|
mod = PyModule_Create(&parsers_module);
|
|
|
module_init(mod);
|
|
|
return mod;
|
|
|
}
|
|
|
#else
|
|
|
PyMODINIT_FUNC initparsers(void)
|
|
|
{
|
|
|
PyObject *mod;
|
|
|
|
|
|
if (check_python_version() == -1) {
|
|
|
return;
|
|
|
}
|
|
|
mod = Py_InitModule3("parsers", methods, parsers_doc);
|
|
|
module_init(mod);
|
|
|
}
|
|
|
#endif
|
|
|
|