This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2181

charencode: allow clang-format oversight
ClosedPublic

Authored by durin42 on Feb 12 2018, 10:44 AM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG6c87d4113a90: charencode: allow clang-format oversight
rHGad352f84b782: charencode: allow clang-format oversight
Summary

Nice and easy.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

durin42 created this revision.Feb 12 2018, 10:44 AM
indygreg requested changes to this revision.Feb 12 2018, 2:20 PM
indygreg added a subscriber: indygreg.

I want a second opinion about the #include order.

mercurial/cext/charencode.h
11–12 ↗(On Diff #5491)

Huh? Why is it putting a system include after a local include? This feels wrong to me.

This revision now requires changes to proceed.Feb 12 2018, 2:20 PM
durin42 added inline comments.Feb 12 2018, 3:10 PM
mercurial/cext/charencode.h
11–12 ↗(On Diff #5491)

Per a colleague, https://clang.llvm.org/docs/ClangFormatStyleOptions.html - look for IncludeCategories.

Basically, it looks like we need to configure that. :/

durin42 updated this revision to Diff 5748.Feb 14 2018, 9:15 PM
indygreg accepted this revision.Feb 14 2018, 11:39 PM
This revision is now accepted and ready to land.Feb 14 2018, 11:39 PM
Closed by commit rHGad352f84b782: charencode: allow clang-format oversight (authored by durin42). · Explain WhyFeb 14 2018, 11:39 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 5748

contrib/clang-format-blacklist

# Files that just need to be migrated to the formatter. # Files that just need to be migrated to the formatter.
# Do not add new files here! # Do not add new files here!
mercurial/cext/base85.c mercurial/cext/base85.c
mercurial/cext/charencode.c
mercurial/cext/charencode.h
mercurial/cext/dirs.c mercurial/cext/dirs.c
mercurial/cext/manifest.c mercurial/cext/manifest.c
mercurial/cext/mpatch.c mercurial/cext/mpatch.c
mercurial/cext/osutil.c mercurial/cext/osutil.c
mercurial/cext/revlog.c mercurial/cext/revlog.c
# Vendored code that we should never format: # Vendored code that we should never format:
contrib/python-zstandard/c-ext/bufferutil.c contrib/python-zstandard/c-ext/bufferutil.c
contrib/python-zstandard/c-ext/compressiondict.c contrib/python-zstandard/c-ext/compressiondict.c

mercurial/cext/charencode.c

} }
for (; i < len; i++) { for (; i < len; i++) {
if (buf[i] & 0x80) if (buf[i] & 0x80)
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
Py_RETURN_TRUE; Py_RETURN_TRUE;
} }
static inline PyObject *_asciitransform(PyObject *str_obj, static inline PyObject *
const char table[128], _asciitransform(PyObject *str_obj, const char table[128], PyObject *fallback_fn)
PyObject *fallback_fn)
{ {
char *str, *newstr; char *str, *newstr;
Py_ssize_t i, len; Py_ssize_t i, len;
PyObject *newobj = NULL; PyObject *newobj = NULL;
PyObject *ret = NULL; PyObject *ret = NULL;
str = PyBytes_AS_STRING(str_obj); str = PyBytes_AS_STRING(str_obj);
len = PyBytes_GET_SIZE(str_obj); len = PyBytes_GET_SIZE(str_obj);
newobj = PyBytes_FromStringAndSize(NULL, len); newobj = PyBytes_FromStringAndSize(NULL, len);
if (!newobj) if (!newobj)
goto quit; goto quit;
newstr = PyBytes_AS_STRING(newobj); newstr = PyBytes_AS_STRING(newobj);
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
char c = str[i]; char c = str[i];
if (c & 0x80) { if (c & 0x80) {
if (fallback_fn != NULL) { if (fallback_fn != NULL) {
ret = PyObject_CallFunctionObjArgs(fallback_fn, ret = PyObject_CallFunctionObjArgs(
str_obj, NULL); fallback_fn, str_obj, NULL);
} else { } else {
PyObject *err = PyUnicodeDecodeError_Create( PyObject *err = PyUnicodeDecodeError_Create(
"ascii", str, len, i, (i + 1), "ascii", str, len, i, (i + 1),
"unexpected code byte"); "unexpected code byte");
PyErr_SetObject(PyExc_UnicodeDecodeError, err); PyErr_SetObject(PyExc_UnicodeDecodeError, err);
Py_XDECREF(err); Py_XDECREF(err);
} }
goto quit; goto quit;
} }
newstr[i] = table[(unsigned char)c]; newstr[i] = table[(unsigned char)c];
} }
PyObject *dmap, *spec_obj, *normcase_fallback; PyObject *dmap, *spec_obj, *normcase_fallback;
PyObject *file_foldmap = NULL; PyObject *file_foldmap = NULL;
enum normcase_spec spec; enum normcase_spec spec;
PyObject *k, *v; PyObject *k, *v;
dirstateTupleObject *tuple; dirstateTupleObject *tuple;
Py_ssize_t pos = 0; Py_ssize_t pos = 0;
const char *table; const char *table;
if (!PyArg_ParseTuple(args, "O!O!O!:make_file_foldmap", if (!PyArg_ParseTuple(args, "O!O!O!:make_file_foldmap", &PyDict_Type,
&PyDict_Type, &dmap, &dmap, &PyInt_Type, &spec_obj, &PyFunction_Type,
&PyInt_Type, &spec_obj, &normcase_fallback))
&PyFunction_Type, &normcase_fallback))
goto quit; goto quit;
spec = (int)PyInt_AS_LONG(spec_obj); spec = (int)PyInt_AS_LONG(spec_obj);
switch (spec) { switch (spec) {
case NORMCASE_LOWER: case NORMCASE_LOWER:
table = lowertable; table = lowertable;
break; break;
case NORMCASE_UPPER: case NORMCASE_UPPER:
function. */ function. */
file_foldmap = _dict_new_presized((PyDict_Size(dmap) / 10) * 11); file_foldmap = _dict_new_presized((PyDict_Size(dmap) / 10) * 11);
if (file_foldmap == NULL) if (file_foldmap == NULL)
goto quit; goto quit;
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 = (dirstateTupleObject *)v; tuple = (dirstateTupleObject *)v;
if (tuple->state != 'r') { if (tuple->state != 'r') {
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);
} }
if (normed == NULL) if (normed == NULL)
goto quit; goto quit;
if (PyDict_SetItem(file_foldmap, normed, k) == -1) { if (PyDict_SetItem(file_foldmap, normed, k) == -1) {
Py_DECREF(normed); Py_DECREF(normed);
goto quit; goto quit;
} }
Py_ssize_t i, esclen = 0; Py_ssize_t i, esclen = 0;
if (paranoid) { if (paranoid) {
/* don't want to process multi-byte escapes in C */ /* don't want to process multi-byte escapes in C */
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
char c = buf[i]; char c = buf[i];
if (c & 0x80) { if (c & 0x80) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"cannot process non-ascii str"); "cannot process non-ascii str");
return -1; return -1;
} }
esclen += jsonparanoidlentable[(unsigned char)c]; esclen += jsonparanoidlentable[(unsigned char)c];
if (esclen < 0) { if (esclen < 0) {
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
"overflow in jsonescapelen"); "overflow in jsonescapelen");
return -1; return -1;
} }
} }
} else { } else {
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
char c = buf[i]; char c = buf[i];
esclen += jsonlentable[(unsigned char)c]; esclen += jsonlentable[(unsigned char)c];
if (esclen < 0) { if (esclen < 0) {
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
"overflow in jsonescapelen"); "overflow in jsonescapelen");
return -1; return -1;
} }
} }
} }
return esclen; return esclen;
} }
return 'f'; return 'f';
case '\r': case '\r':
return 'r'; return 'r';
case '"': case '"':
return '"'; return '"';
case '\\': case '\\':
return '\\'; return '\\';
} }
return '\0'; /* should not happen */ return '\0'; /* should not happen */
} }
/* convert 'origbuf' to JSON-escaped form 'escbuf'; 'origbuf' should only /* convert 'origbuf' to JSON-escaped form 'escbuf'; 'origbuf' should only
include characters mappable by json(paranoid)lentable */ include characters mappable by json(paranoid)lentable */
static void encodejsonescape(char *escbuf, Py_ssize_t esclen, static void encodejsonescape(char *escbuf, Py_ssize_t esclen,
const char *origbuf, Py_ssize_t origlen, const char *origbuf, Py_ssize_t origlen,
bool paranoid) bool paranoid)
{ {
const uint8_t *lentable = const uint8_t *lentable =
(paranoid) ? jsonparanoidlentable : jsonlentable; (paranoid) ? jsonparanoidlentable : jsonlentable;
Py_ssize_t i, j; Py_ssize_t i, j;
for (i = 0, j = 0; i < origlen; i++) { for (i = 0, j = 0; i < origlen; i++) {
char c = origbuf[i]; char c = origbuf[i];
uint8_t l = lentable[(unsigned char)c]; uint8_t l = lentable[(unsigned char)c];
assert(j + l <= esclen); assert(j + l <= esclen);
switch (l) { switch (l) {
case 1: case 1:
} }
PyObject *jsonescapeu8fast(PyObject *self, PyObject *args) PyObject *jsonescapeu8fast(PyObject *self, PyObject *args)
{ {
PyObject *origstr, *escstr; PyObject *origstr, *escstr;
const char *origbuf; const char *origbuf;
Py_ssize_t origlen, esclen; Py_ssize_t origlen, esclen;
int paranoid; int paranoid;
if (!PyArg_ParseTuple(args, "O!i:jsonescapeu8fast", if (!PyArg_ParseTuple(args, "O!i:jsonescapeu8fast", &PyBytes_Type,
&PyBytes_Type, &origstr, &paranoid)) &origstr, &paranoid))
return NULL; return NULL;
origbuf = PyBytes_AS_STRING(origstr); origbuf = PyBytes_AS_STRING(origstr);
origlen = PyBytes_GET_SIZE(origstr); origlen = PyBytes_GET_SIZE(origstr);
esclen = jsonescapelen(origbuf, origlen, paranoid); esclen = jsonescapelen(origbuf, origlen, paranoid);
if (esclen < 0) if (esclen < 0)
return NULL; /* unsupported char found or overflow */ return NULL; /* unsupported char found or overflow */
if (origlen == esclen) { if (origlen == esclen) {
Py_INCREF(origstr); Py_INCREF(origstr);
return origstr; return origstr;
} }
escstr = PyBytes_FromStringAndSize(NULL, esclen); escstr = PyBytes_FromStringAndSize(NULL, esclen);
if (!escstr) if (!escstr)
return NULL; return NULL;
encodejsonescape(PyBytes_AS_STRING(escstr), esclen, origbuf, origlen, encodejsonescape(PyBytes_AS_STRING(escstr), esclen, origbuf, origlen,
paranoid); paranoid);
return escstr; return escstr;
} }