( )⚙ D2587 cext: accept arguments as Py_buffer

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2587

cext: accept arguments as Py_buffer
ClosedPublic

Authored by indygreg on Mar 3 2018, 11:28 AM.

Details

Reviewers
yuja
Group Reviewers
hg-reviewers
Commits
rHG68026dd7c4f9: cext: accept arguments as Py_buffer
Summary

The s*/y* value formatters receive a Py_buffer instead of a char *.
This value format is more flexible in the types that it allows.

We change bdiff() to accept any object that conforms to the buffer
protocol. We validate the buffers are contiguous and have a single
dimension.

This allows memoryview instances to be handled by the function, so
we revert a recent change to cast arguments to bytes before calling
this function.

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 3 2018, 11:28 AM
yuja accepted this revision.Mar 3 2018, 3:02 PM
This revision is now accepted and ready to land.Mar 3 2018, 3:02 PM
Closed by commit rHG68026dd7c4f9: cext: accept arguments as Py_buffer (authored by indygreg). · Explain WhyMar 3 2018, 3:15 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/cext/bdiff.c (31 lines)
Mmercurial/mdiff.py (10 lines)

Diff 6466

mercurial/cext/bdiff.c

free(a); free(a);
free(b); free(b);
bdiff_freehunks(l.next); bdiff_freehunks(l.next);
return rl ? rl : PyErr_NoMemory(); return rl ? rl : PyErr_NoMemory();
} }
static PyObject *bdiff(PyObject *self, PyObject *args) static PyObject *bdiff(PyObject *self, PyObject *args)
{ {
char *sa, *sb, *rb, *ia, *ib; Py_buffer ba, bb;
char *rb, *ia, *ib;
PyObject *result = NULL; PyObject *result = NULL;
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"), &sa, &la, if (!PyArg_ParseTuple(args, PY23("s*s*:bdiff", "y*y*:bdiff"), &ba, &bb))
&sb, &lb))
return NULL; return NULL;
if (!PyBuffer_IsContiguous(&ba, 'C') || ba.ndim > 1) {
PyErr_SetString(PyExc_ValueError, "bdiff input not contiguous");
goto cleanup;
}
if (!PyBuffer_IsContiguous(&bb, 'C') || bb.ndim > 1) {
PyErr_SetString(PyExc_ValueError, "bdiff input not contiguous");
goto cleanup;
}
la = ba.len;
lb = bb.len;
if (la > UINT_MAX || lb > UINT_MAX) { if (la > UINT_MAX || lb > UINT_MAX) {
PyErr_SetString(PyExc_ValueError, "bdiff inputs too large"); PyErr_SetString(PyExc_ValueError, "bdiff inputs too large");
return NULL; goto cleanup;
} }
_save = PyEval_SaveThread(); _save = PyEval_SaveThread();
lmax = la > lb ? lb : la; lmax = la > lb ? lb : la;
for (ia = sa, ib = sb; li < lmax && *ia == *ib; ++li, ++ia, ++ib) for (ia = ba.buf, ib = bb.buf; li < lmax && *ia == *ib;
++li, ++ia, ++ib) {
if (*ia == '\n') if (*ia == '\n')
lcommon = li + 1; lcommon = li + 1;
}
/* we can almost add: if (li == lmax) lcommon = li; */ /* we can almost add: if (li == lmax) lcommon = li; */
an = bdiff_splitlines(sa + lcommon, la - lcommon, &al); an = bdiff_splitlines(ba.buf + lcommon, la - lcommon, &al);
bn = bdiff_splitlines(sb + lcommon, lb - lcommon, &bl); bn = bdiff_splitlines(bb.buf + lcommon, lb - lcommon, &bl);
if (!al || !bl) { if (!al || !bl) {
PyErr_NoMemory(); PyErr_NoMemory();
goto cleanup; goto cleanup;
} }
count = bdiff_diff(al, an, bl, bn, &l); count = bdiff_diff(al, an, bl, bn, &l);
if (count < 0) { if (count < 0) {
PyErr_NoMemory(); PyErr_NoMemory();
} }
la = h->a2; la = h->a2;
lb = h->b2; lb = h->b2;
} }
cleanup: cleanup:
if (_save) if (_save)
PyEval_RestoreThread(_save); PyEval_RestoreThread(_save);
PyBuffer_Release(&ba);
PyBuffer_Release(&bb);
if (al) { if (al) {
free(al); free(al);
} }
if (bl) { if (bl) {
free(bl); free(bl);
} }
if (l.next) { if (l.next) {
bdiff_freehunks(l.next); bdiff_freehunks(l.next);

mercurial/mdiff.py

bdiff = policy.importmod(r'bdiff') bdiff = policy.importmod(r'bdiff')
mpatch = policy.importmod(r'mpatch') mpatch = policy.importmod(r'mpatch')
blocks = bdiff.blocks blocks = bdiff.blocks
fixws = bdiff.fixws fixws = bdiff.fixws
patches = mpatch.patches patches = mpatch.patches
patchedsize = mpatch.patchedsize patchedsize = mpatch.patchedsize
_textdiff = bdiff.bdiff textdiff = bdiff.bdiff
splitnewlines = bdiff.splitnewlines splitnewlines = bdiff.splitnewlines
# On Python 3, util.buffer() creates a memoryview, which appears not
# supporting the buffer protocol
if pycompat.ispy3:
def textdiff(a, b):
return _textdiff(bytes(a), bytes(b))
else:
textdiff = _textdiff
class diffopts(object): class diffopts(object):
'''context is the number of context lines '''context is the number of context lines
text treats all files as text text treats all files as text
showfunc enables diff -p output showfunc enables diff -p output
git enables the git extended patch format git enables the git extended patch format
nodates removes dates from diff headers nodates removes dates from diff headers
nobinary ignores binary files nobinary ignores binary files
noprefix disables the 'a/' and 'b/' prefixes (ignored in plain mode) noprefix disables the 'a/' and 'b/' prefixes (ignored in plain mode)