( )⚙ D12232 cext: remove PY23()

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12232

cext: remove PY23()
ClosedPublic

Authored by indygreg on Mar 1 2022, 7:22 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGb0dd39b91e7a: cext: remove PY23()
Summary

Since we always run on Python 3 now, we no longer need this
macro to support Python 2. We refactor all users to just use
the 2nd argument.

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.

Event Timeline

indygreg created this revision.Mar 1 2022, 7:22 PM
Alphare accepted this revision.Mar 2 2022, 5:21 AM
This revision is now accepted and ready to land.Mar 2 2022, 5:21 AM
indygreg added a commit: rHGb0dd39b91e7a: cext: remove PY23().Mar 2 2022, 7:42 AM
Closed by commit rHGb0dd39b91e7a: cext: remove PY23() (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 32348

mercurial/cext/base85.c

{ {
const unsigned char *text; const unsigned char *text;
PyObject *out; PyObject *out;
char *dst; char *dst;
Py_ssize_t len, olen, i; Py_ssize_t len, olen, i;
unsigned int acc, val, ch; unsigned int acc, val, ch;
int pad = 0; int pad = 0;
if (!PyArg_ParseTuple(args, PY23("s#|i", "y#|i"), &text, &len, &pad)) { if (!PyArg_ParseTuple(args, "y#|i", &text, &len, &pad)) {
return NULL; return NULL;
} }
if (pad) { if (pad) {
olen = ((len + 3) / 4 * 5) - 3; olen = ((len + 3) / 4 * 5) - 3;
} else { } else {
olen = len % 4; olen = len % 4;
if (olen) { if (olen) {
{ {
PyObject *out = NULL; PyObject *out = NULL;
const char *text; const char *text;
char *dst; char *dst;
Py_ssize_t len, i, j, olen, cap; Py_ssize_t len, i, j, olen, cap;
int c; int c;
unsigned int acc; unsigned int acc;
if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &text, &len)) { if (!PyArg_ParseTuple(args, "y#", &text, &len)) {
return NULL; return NULL;
} }
olen = len / 5 * 4; olen = len / 5 * 4;
i = len % 5; i = len % 5;
if (i) { if (i) {
olen += i - 1; olen += i - 1;
} }

mercurial/cext/bdiff.c

struct bdiff_line *al = NULL, *bl = NULL; struct bdiff_line *al = NULL, *bl = NULL;
struct bdiff_hunk l, *h; struct bdiff_hunk l, *h;
int an, bn, count; int an, bn, count;
Py_ssize_t len = 0, la, lb, li = 0, lcommon = 0, lmax; Py_ssize_t len = 0, la, lb, li = 0, lcommon = 0, lmax;
PyThreadState *_save = NULL; PyThreadState *_save = NULL;
l.next = NULL; l.next = NULL;
if (!PyArg_ParseTuple(args, PY23("s*s*:bdiff", "y*y*:bdiff"), &ba, if (!PyArg_ParseTuple(args, "y*y*:bdiff", &ba, &bb)) {
&bb)) {
return NULL; return NULL;
} }
if (!PyBuffer_IsContiguous(&ba, 'C') || ba.ndim > 1) { if (!PyBuffer_IsContiguous(&ba, 'C') || ba.ndim > 1) {
PyErr_SetString(PyExc_ValueError, "bdiff input not contiguous"); PyErr_SetString(PyExc_ValueError, "bdiff input not contiguous");
goto cleanup; goto cleanup;
} }
} }
static PyObject *splitnewlines(PyObject *self, PyObject *args) static PyObject *splitnewlines(PyObject *self, PyObject *args)
{ {
const char *text; const char *text;
Py_ssize_t nelts = 0, size, i, start = 0; Py_ssize_t nelts = 0, size, i, start = 0;
PyObject *result = NULL; PyObject *result = NULL;
if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &text, &size)) { if (!PyArg_ParseTuple(args, "y#", &text, &size)) {
goto abort; goto abort;
} }
if (!size) { if (!size) {
return PyList_New(0); return PyList_New(0);
} }
/* This loops to size-1 because if the last byte is a newline, /* This loops to size-1 because if the last byte is a newline,
* we don't want to perform a split there. */ * we don't want to perform a split there. */
for (i = 0; i < size - 1; ++i) { for (i = 0; i < size - 1; ++i) {
xdemitconf_t xecfg = { xdemitconf_t xecfg = {
XDL_EMIT_BDIFFHUNK, /* flags */ XDL_EMIT_BDIFFHUNK, /* flags */
hunk_consumer, /* hunk_consume_func */ hunk_consumer, /* hunk_consume_func */
}; };
xdemitcb_t ecb = { xdemitcb_t ecb = {
NULL, /* priv */ NULL, /* priv */
}; };
if (!PyArg_ParseTuple(args, PY23("s#s#", "y#y#"), &a.ptr, &la, &b.ptr, if (!PyArg_ParseTuple(args, "y#y#", &a.ptr, &la, &b.ptr, &lb)) {
&lb)) {
return NULL; return NULL;
} }
a.size = la; a.size = la;
b.size = lb; b.size = lb;
rl = PyList_New(0); rl = PyList_New(0);
if (!rl) { if (!rl) {

mercurial/cext/charencode.c

return ret; return ret;
} }
PyObject *isasciistr(PyObject *self, PyObject *args) PyObject *isasciistr(PyObject *self, PyObject *args)
{ {
const char *buf; const char *buf;
Py_ssize_t i, len; Py_ssize_t i, len;
if (!PyArg_ParseTuple(args, PY23("s#:isasciistr", "y#:isasciistr"), if (!PyArg_ParseTuple(args, "y#:isasciistr", &buf, &len)) {
&buf, &len)) {
return NULL; return NULL;
} }
i = 0; i = 0;
/* char array in PyStringObject should be at least 4-byte aligned */ /* char array in PyStringObject should be at least 4-byte aligned */
if (((uintptr_t)buf & 3) == 0) { if (((uintptr_t)buf & 3) == 0) {
const uint32_t *p = (const uint32_t *)buf; const uint32_t *p = (const uint32_t *)buf;
for (; i < len / 4; i++) { for (; i < len / 4; i++) {
if (p[i] & 0x80808080U) { if (p[i] & 0x80808080U) {

mercurial/cext/manifest.c

goto nomem; goto nomem;
} }
copy->maxlines = self->maxlines; copy->maxlines = self->maxlines;
copy->numlines = 0; copy->numlines = 0;
copy->pydata = self->pydata; copy->pydata = self->pydata;
Py_INCREF(copy->pydata); Py_INCREF(copy->pydata);
for (i = 0; i < self->numlines; i++) { for (i = 0; i < self->numlines; i++) {
PyObject *arglist = NULL, *result = NULL; PyObject *arglist = NULL, *result = NULL;
arglist = Py_BuildValue(PY23("(s)", "(y)"), arglist = Py_BuildValue("(y)",
self->lines[i].start); self->lines[i].start);
if (!arglist) { if (!arglist) {
goto bail; goto bail;
} }
result = PyObject_CallObject(matchfn, arglist); result = PyObject_CallObject(matchfn, arglist);
Py_DECREF(arglist); Py_DECREF(arglist);
/* if the callback raised an exception, just let it /* if the callback raised an exception, just let it
* through and give up */ * through and give up */

mercurial/cext/mpatch.c

/* calculate size of a patched file directly */ /* calculate size of a patched file directly */
static PyObject *patchedsize(PyObject *self, PyObject *args) static PyObject *patchedsize(PyObject *self, PyObject *args)
{ {
long orig, start, end, len, outlen = 0, last = 0, pos = 0; long orig, start, end, len, outlen = 0, last = 0, pos = 0;
Py_ssize_t patchlen; Py_ssize_t patchlen;
char *bin; char *bin;
if (!PyArg_ParseTuple(args, PY23("ls#", "ly#"), &orig, &bin, if (!PyArg_ParseTuple(args, "ly#", &orig, &bin, &patchlen)) {
&patchlen)) {
return NULL; return NULL;
} }
while (pos >= 0 && pos < patchlen) { while (pos >= 0 && pos < patchlen) {
start = getbe32(bin + pos); start = getbe32(bin + pos);
end = getbe32(bin + pos + 4); end = getbe32(bin + pos + 4);
len = getbe32(bin + pos + 8); len = getbe32(bin + pos + 8);
if (start > end) { if (start > end) {

mercurial/cext/osutil.c

{ {
PyObject *py_st; PyObject *py_st;
struct hg_stat *stp; struct hg_stat *stp;
int kind = (fd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) int kind = (fd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
? _S_IFDIR : _S_IFREG; ? _S_IFDIR : _S_IFREG;
if (!wantstat) if (!wantstat)
return Py_BuildValue(PY23("si", "yi"), fd->cFileName, kind); return Py_BuildValue("yi", fd->cFileName, kind);
py_st = PyObject_CallObject((PyObject *)&listdir_stat_type, NULL); py_st = PyObject_CallObject((PyObject *)&listdir_stat_type, NULL);
if (!py_st) if (!py_st)
return NULL; return NULL;
stp = &((struct listdir_stat *)py_st)->st; stp = &((struct listdir_stat *)py_st)->st;
/* /*
use kind as st_mode use kind as st_mode
rwx bits on Win32 are meaningless rwx bits on Win32 are meaningless
and Hg does not use them anyway and Hg does not use them anyway
*/ */
stp->st_mode = kind; stp->st_mode = kind;
stp->st_mtime = to_python_time(&fd->ftLastWriteTime); stp->st_mtime = to_python_time(&fd->ftLastWriteTime);
stp->st_ctime = to_python_time(&fd->ftCreationTime); stp->st_ctime = to_python_time(&fd->ftCreationTime);
if (kind == _S_IFREG) if (kind == _S_IFREG)
stp->st_size = ((__int64)fd->nFileSizeHigh << 32) stp->st_size = ((__int64)fd->nFileSizeHigh << 32)
+ fd->nFileSizeLow; + fd->nFileSizeLow;
return Py_BuildValue(PY23("siN", "yiN"), fd->cFileName, return Py_BuildValue("yiN", fd->cFileName,
kind, py_st); kind, py_st);
} }
static PyObject *_listdir(char *path, Py_ssize_t plen, int wantstat, char *skip) static PyObject *_listdir(char *path, Py_ssize_t plen, int wantstat, char *skip)
{ {
PyObject *rval = NULL; /* initialize - return value */ PyObject *rval = NULL; /* initialize - return value */
PyObject *list; PyObject *list;
HANDLE fh; HANDLE fh;
ret = PyList_New(0); ret = PyList_New(0);
goto error; goto error;
} }
if (keepstat) { if (keepstat) {
PyObject *stat = makestat(&st); PyObject *stat = makestat(&st);
if (!stat) if (!stat)
goto error; goto error;
elem = Py_BuildValue(PY23("siN", "yiN"), ent->d_name, elem = Py_BuildValue("yiN", ent->d_name,
kind, stat); kind, stat);
} else } else
elem = Py_BuildValue(PY23("si", "yi"), ent->d_name, elem = Py_BuildValue("yi", ent->d_name,
kind); kind);
if (!elem) if (!elem)
goto error; goto error;
PyList_Append(list, elem); PyList_Append(list, elem);
Py_DECREF(elem); Py_DECREF(elem);
} }
/* from the getattrlist(2) man page: "Only the /* from the getattrlist(2) man page: "Only the
permission bits ... are valid". */ permission bits ... are valid". */
st.st_mode = (entry->access_mask & ~S_IFMT) | kind; st.st_mode = (entry->access_mask & ~S_IFMT) | kind;
st.st_mtime = entry->mtime.tv_sec; st.st_mtime = entry->mtime.tv_sec;
st.st_size = entry->size; st.st_size = entry->size;
stat = makestat(&st); stat = makestat(&st);
if (!stat) if (!stat)
goto error; goto error;
elem = Py_BuildValue(PY23("siN", "yiN"), elem = Py_BuildValue("yiN",
filename, kind, stat); filename, kind, stat);
} else } else
elem = Py_BuildValue(PY23("si", "yi"), elem = Py_BuildValue("yi",
filename, kind); filename, kind);
if (!elem) if (!elem)
goto error; goto error;
PyList_Append(list, elem); PyList_Append(list, elem);
Py_DECREF(elem); Py_DECREF(elem);
entry = (attrbuf_entry *)((char *)entry + entry->length); entry = (attrbuf_entry *)((char *)entry + entry->length);
#define SETPROCNAME_USE_NONE #define SETPROCNAME_USE_NONE
#endif #endif
#endif /* ndef SETPROCNAME_USE_NONE */ #endif /* ndef SETPROCNAME_USE_NONE */
#ifndef SETPROCNAME_USE_NONE #ifndef SETPROCNAME_USE_NONE
static PyObject *setprocname(PyObject *self, PyObject *args) static PyObject *setprocname(PyObject *self, PyObject *args)
{ {
const char *name = NULL; const char *name = NULL;
if (!PyArg_ParseTuple(args, PY23("s", "y"), &name)) if (!PyArg_ParseTuple(args, "y", &name))
return NULL; return NULL;
#if defined(SETPROCNAME_USE_SETPROCTITLE) #if defined(SETPROCNAME_USE_SETPROCTITLE)
setproctitle("%s", name); setproctitle("%s", name);
#elif defined(SETPROCNAME_USE_ARGVREWRITE) #elif defined(SETPROCNAME_USE_ARGVREWRITE)
{ {
static char *argvstart = NULL; static char *argvstart = NULL;
static size_t argvsize = 0; static size_t argvsize = 0;
#if defined(HAVE_BSD_STATFS) || defined(HAVE_LINUX_STATFS) #if defined(HAVE_BSD_STATFS) || defined(HAVE_LINUX_STATFS)
/* given a directory path, return filesystem type name (best-effort) */ /* given a directory path, return filesystem type name (best-effort) */
static PyObject *getfstype(PyObject *self, PyObject *args) static PyObject *getfstype(PyObject *self, PyObject *args)
{ {
const char *path = NULL; const char *path = NULL;
struct statfs buf; struct statfs buf;
int r; int r;
if (!PyArg_ParseTuple(args, PY23("s", "y"), &path)) if (!PyArg_ParseTuple(args, "y", &path))
return NULL; return NULL;
memset(&buf, 0, sizeof(buf)); memset(&buf, 0, sizeof(buf));
r = statfs(path, &buf); r = statfs(path, &buf);
if (r != 0) if (r != 0)
return PyErr_SetFromErrno(PyExc_OSError); return PyErr_SetFromErrno(PyExc_OSError);
return Py_BuildValue(PY23("s", "y"), describefstype(&buf)); return Py_BuildValue("y", describefstype(&buf));
} }
#endif /* defined(HAVE_LINUX_STATFS) || defined(HAVE_BSD_STATFS) */ #endif /* defined(HAVE_LINUX_STATFS) || defined(HAVE_BSD_STATFS) */
#if defined(HAVE_BSD_STATFS) #if defined(HAVE_BSD_STATFS)
/* given a directory path, return filesystem mount point (best-effort) */ /* given a directory path, return filesystem mount point (best-effort) */
static PyObject *getfsmountpoint(PyObject *self, PyObject *args) static PyObject *getfsmountpoint(PyObject *self, PyObject *args)
{ {
const char *path = NULL; const char *path = NULL;
struct statfs buf; struct statfs buf;
int r; int r;
if (!PyArg_ParseTuple(args, PY23("s", "y"), &path)) if (!PyArg_ParseTuple(args, "y", &path))
return NULL; return NULL;
memset(&buf, 0, sizeof(buf)); memset(&buf, 0, sizeof(buf));
r = statfs(path, &buf); r = statfs(path, &buf);
if (r != 0) if (r != 0)
return PyErr_SetFromErrno(PyExc_OSError); return PyErr_SetFromErrno(PyExc_OSError);
return Py_BuildValue(PY23("s", "y"), buf.f_mntonname); return Py_BuildValue("y", buf.f_mntonname);
} }
#endif /* defined(HAVE_BSD_STATFS) */ #endif /* defined(HAVE_BSD_STATFS) */
static PyObject *unblocksignal(PyObject *self, PyObject *args) static PyObject *unblocksignal(PyObject *self, PyObject *args)
{ {
int sig = 0; int sig = 0;
sigset_t set; sigset_t set;
int r; int r;
PyObject *statobj = NULL; /* initialize - optional arg */ PyObject *statobj = NULL; /* initialize - optional arg */
PyObject *skipobj = NULL; /* initialize - optional arg */ PyObject *skipobj = NULL; /* initialize - optional arg */
char *path, *skip = NULL; char *path, *skip = NULL;
Py_ssize_t plen; Py_ssize_t plen;
int wantstat; int wantstat;
static char *kwlist[] = {"path", "stat", "skip", NULL}; static char *kwlist[] = {"path", "stat", "skip", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, PY23("s#|OO:listdir", if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y#|OO:listdir",
"y#|OO:listdir"),
kwlist, &path, &plen, &statobj, &skipobj)) kwlist, &path, &plen, &statobj, &skipobj))
return NULL; return NULL;
wantstat = statobj && PyObject_IsTrue(statobj); wantstat = statobj && PyObject_IsTrue(statobj);
if (skipobj && skipobj != Py_None) { if (skipobj && skipobj != Py_None) {
skip = PyBytes_AsString(skipobj); skip = PyBytes_AsString(skipobj);
if (!skip) if (!skip)
int fd, flags = 0; int fd, flags = 0;
int bufsize = -1; int bufsize = -1;
char m0, m1, m2; char m0, m1, m2;
char fpmode[4]; char fpmode[4];
int fppos = 0; int fppos = 0;
int plus; int plus;
FILE *fp; FILE *fp;
if (!PyArg_ParseTupleAndKeywords(args, kwds, PY23("et|si:posixfile", if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|yi:posixfile",
"et|yi:posixfile"),
kwlist, kwlist,
Py_FileSystemDefaultEncoding, Py_FileSystemDefaultEncoding,
&name, &mode, &bufsize)) &name, &mode, &bufsize))
return NULL; return NULL;
m0 = mode[0]; m0 = mode[0];
m1 = m0 ? mode[1] : '\0'; m1 = m0 ? mode[1] : '\0';
m2 = m1 ? mode[2] : '\0'; m2 = m1 ? mode[2] : '\0';

mercurial/cext/parsers.c

PyObject *dmap, *cmap, *parents = NULL, *ret = NULL; PyObject *dmap, *cmap, *parents = NULL, *ret = NULL;
PyObject *fname = NULL, *cname = NULL, *entry = NULL; PyObject *fname = NULL, *cname = NULL, *entry = NULL;
char state, *cur, *str, *cpos; char state, *cur, *str, *cpos;
int mode, size, mtime; int mode, size, mtime;
unsigned int flen, pos = 40; unsigned int flen, pos = 40;
Py_ssize_t len = 40; Py_ssize_t len = 40;
Py_ssize_t readlen; Py_ssize_t readlen;
if (!PyArg_ParseTuple( if (!PyArg_ParseTuple(args, "O!O!y#:parse_dirstate", &PyDict_Type,
args, PY23("O!O!s#:parse_dirstate", "O!O!y#:parse_dirstate"), &dmap, &PyDict_Type, &cmap, &str, &readlen)) {
&PyDict_Type, &dmap, &PyDict_Type, &cmap, &str, &readlen)) {
goto quit; goto quit;
} }
len = readlen; len = readlen;
/* read parents */ /* read parents */
if (len < 40) { if (len < 40) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"too little data for parents"); "too little data for parents");
goto quit; goto quit;
} }
parents = Py_BuildValue(PY23("s#s#", "y#y#"), str, (Py_ssize_t)20, parents = Py_BuildValue("y#y#", str, (Py_ssize_t)20, str + 20,
str + 20, (Py_ssize_t)20); (Py_ssize_t)20);
if (!parents) { if (!parents) {
goto quit; goto quit;
} }
/* read filenames */ /* read filenames */
while (pos >= 40 && pos < len) { while (pos >= 40 && pos < len) {
if (pos + 17 > len) { if (pos + 17 > len) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
} }
static PyObject *fm1readmarkers(PyObject *self, PyObject *args) static PyObject *fm1readmarkers(PyObject *self, PyObject *args)
{ {
const char *data, *dataend; const char *data, *dataend;
Py_ssize_t datalen, offset, stop; Py_ssize_t datalen, offset, stop;
PyObject *markers = NULL; PyObject *markers = NULL;
if (!PyArg_ParseTuple(args, PY23("s#nn", "y#nn"), &data, &datalen, if (!PyArg_ParseTuple(args, "y#nn", &data, &datalen, &offset, &stop)) {
&offset, &stop)) {
return NULL; return NULL;
} }
if (offset < 0) { if (offset < 0) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"invalid negative offset in fm1readmarkers"); "invalid negative offset in fm1readmarkers");
return NULL; return NULL;
} }
if (stop > datalen) { if (stop > datalen) {

mercurial/cext/pathencode.c

} }
PyObject *lowerencode(PyObject *self, PyObject *args) PyObject *lowerencode(PyObject *self, PyObject *args)
{ {
char *path; char *path;
Py_ssize_t len, newlen; Py_ssize_t len, newlen;
PyObject *ret; PyObject *ret;
if (!PyArg_ParseTuple(args, PY23("s#:lowerencode", "y#:lowerencode"), if (!PyArg_ParseTuple(args, "y#:lowerencode", &path, &len)) {
&path, &len)) {
return NULL; return NULL;
} }
newlen = _lowerencode(NULL, 0, path, len); newlen = _lowerencode(NULL, 0, path, len);
ret = PyBytes_FromStringAndSize(NULL, newlen); ret = PyBytes_FromStringAndSize(NULL, newlen);
if (ret) { if (ret) {
_lowerencode(PyBytes_AS_STRING(ret), newlen, path, len); _lowerencode(PyBytes_AS_STRING(ret), newlen, path, len);
} }
if (shafunc == NULL) { if (shafunc == NULL) {
PyErr_SetString(PyExc_AttributeError, PyErr_SetString(PyExc_AttributeError,
"module 'hashlib' has no " "module 'hashlib' has no "
"attribute 'sha1' in pathencode"); "attribute 'sha1' in pathencode");
return -1; return -1;
} }
} }
shaobj = PyObject_CallFunction(shafunc, PY23("s#", "y#"), str, len); shaobj = PyObject_CallFunction(shafunc, "y#", str, len);
if (shaobj == NULL) { if (shaobj == NULL) {
return -1; return -1;
} }
hashobj = PyObject_CallMethod(shaobj, "digest", ""); hashobj = PyObject_CallMethod(shaobj, "digest", "");
Py_DECREF(shaobj); Py_DECREF(shaobj);
if (hashobj == NULL) { if (hashobj == NULL) {

mercurial/cext/revlog.c

static const char nullid[32] = {0}; static const char nullid[32] = {0};
static const Py_ssize_t nullrev = -1; static const Py_ssize_t nullrev = -1;
static Py_ssize_t inline_scan(indexObject *self, const char **offsets); static Py_ssize_t inline_scan(indexObject *self, const char **offsets);
static int index_find_node(indexObject *self, const char *node); static int index_find_node(indexObject *self, const char *node);
#if LONG_MAX == 0x7fffffffL #if LONG_MAX == 0x7fffffffL
static const char *const tuple_format = static const char *const tuple_format = "Kiiiiiiy#KiBBi";
PY23("Kiiiiiis#KiBBi", "Kiiiiiiy#KiBBi");
#else #else
static const char *const tuple_format = static const char *const tuple_format = "kiiiiiiy#kiBBi";
PY23("kiiiiiis#kiBBi", "kiiiiiiy#kiBBi");
#endif #endif
/* A RevlogNG v1 index entry is 64 bytes long. */ /* A RevlogNG v1 index entry is 64 bytes long. */
static const long v1_entry_size = 64; static const long v1_entry_size = 64;
/* A Revlogv2 index entry is 96 bytes long. */ /* A Revlogv2 index entry is 96 bytes long. */
static const long v2_entry_size = 96; static const long v2_entry_size = 96;
static PyObject *index_replace_sidedata_info(indexObject *self, PyObject *args) static PyObject *index_replace_sidedata_info(indexObject *self, PyObject *args)
{ {
uint64_t offset_flags, sidedata_offset; uint64_t offset_flags, sidedata_offset;
Py_ssize_t rev; Py_ssize_t rev;
int sidedata_comp_len; int sidedata_comp_len;
char comp_mode; char comp_mode;
char *data; char *data;
#if LONG_MAX == 0x7fffffffL #if LONG_MAX == 0x7fffffffL
const char *const sidedata_format = PY23("nKiKB", "nKiKB"); const char *const sidedata_format = "nKiKB";
#else #else
const char *const sidedata_format = PY23("nkikB", "nkikB"); const char *const sidedata_format = "nkikB";
#endif #endif
if (self->entry_size == v1_entry_size || self->inlined) { if (self->entry_size == v1_entry_size || self->inlined) {
/* /*
There is a bug in the transaction handling when going from an There is a bug in the transaction handling when going from an
inline revlog to a separate index and data file. Turn it off until inline revlog to a separate index and data file. Turn it off until
it's fixed, since v2 revlogs sometimes get rewritten on exchange. it's fixed, since v2 revlogs sometimes get rewritten on exchange.
See issue6485. See issue6485.
static PyObject *index_partialmatch(indexObject *self, PyObject *args) static PyObject *index_partialmatch(indexObject *self, PyObject *args)
{ {
const char *fullnode; const char *fullnode;
Py_ssize_t nodelen; Py_ssize_t nodelen;
char *node; char *node;
int rev, i; int rev, i;
if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &node, &nodelen)) if (!PyArg_ParseTuple(args, "y#", &node, &nodelen))
return NULL; return NULL;
if (nodelen < 1) { if (nodelen < 1) {
PyErr_SetString(PyExc_ValueError, "key too short"); PyErr_SetString(PyExc_ValueError, "key too short");
return NULL; return NULL;
} }
if (nodelen > 2 * self->nodelen) { if (nodelen > 2 * self->nodelen) {
if (self->format_version == format_v1) { if (self->format_version == format_v1) {
self->entry_size = v1_entry_size; self->entry_size = v1_entry_size;
} else if (self->format_version == format_v2) { } else if (self->format_version == format_v2) {
self->entry_size = v2_entry_size; self->entry_size = v2_entry_size;
} else if (self->format_version == format_cl2) { } else if (self->format_version == format_cl2) {
self->entry_size = cl2_entry_size; self->entry_size = cl2_entry_size;
} }
self->nullentry = self->nullentry = Py_BuildValue(
Py_BuildValue(PY23("iiiiiiis#iiBBi", "iiiiiiiy#iiBBi"), 0, 0, 0, -1, "iiiiiiiy#iiBBi", 0, 0, 0, -1, -1, -1, -1, nullid, self->nodelen, 0,
-1, -1, -1, nullid, self->nodelen, 0, 0, 0, comp_mode_inline, comp_mode_inline, rank_unknown);
comp_mode_inline, comp_mode_inline, rank_unknown);
if (!self->nullentry) if (!self->nullentry)
return -1; return -1;
PyObject_GC_UnTrack(self->nullentry); PyObject_GC_UnTrack(self->nullentry);
if (PyObject_GetBuffer(data_obj, &self->buf, PyBUF_SIMPLE) == -1) if (PyObject_GetBuffer(data_obj, &self->buf, PyBUF_SIMPLE) == -1)
return -1; return -1;
size = self->buf.len; size = self->buf.len;

mercurial/cext/util.h

/* /*
util.h - utility functions for interfacing with the various python APIs. util.h - utility functions for interfacing with the various python APIs.
This software may be used and distributed according to the terms of This software may be used and distributed according to the terms of
the GNU General Public License, incorporated herein by reference. the GNU General Public License, incorporated herein by reference.
*/ */
#ifndef _HG_UTIL_H_ #ifndef _HG_UTIL_H_
#define _HG_UTIL_H_ #define _HG_UTIL_H_
#include "compat.h" #include "compat.h"
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
#define IS_PY3K #define IS_PY3K
#endif #endif
/* helper to switch things like string literal depending on Python version */
#ifdef IS_PY3K
#define PY23(py2, py3) py3
#else
#define PY23(py2, py3) py2
#endif
/* clang-format off */ /* clang-format off */
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
int flags; int flags;
int mode; int mode;
int size; int size;
int mtime_s; int mtime_s;
int mtime_ns; int mtime_ns;