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

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

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 5491

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/bdiff.c mercurial/cext/bdiff.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.h

/* /*
charencode.h - miscellaneous character encoding charencode.h - miscellaneous character encoding
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_CHARENCODE_H_ #ifndef _HG_CHARENCODE_H_
#define _HG_CHARENCODE_H_ #define _HG_CHARENCODE_H_
#include <Python.h>
#include "compat.h" #include "compat.h"
#include <Python.h>
indygregUnsubmitted
Not Done

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

indygreg: Huh? Why is it putting a system include after a local include? This feels wrong to me.
durin42AuthorUnsubmitted
Not Done

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

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

durin42: Per a colleague, https://clang.llvm.org/docs/ClangFormatStyleOptions.html - look for…
/* This should be kept in sync with normcasespecs in encoding.py. */ /* This should be kept in sync with normcasespecs in encoding.py. */
enum normcase_spec { enum normcase_spec {
NORMCASE_LOWER = -1, NORMCASE_LOWER = -1,
NORMCASE_UPPER = 1, NORMCASE_UPPER = 1,
NORMCASE_OTHER = 0 NORMCASE_OTHER = 0
}; };

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;
} }