This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7913

cext: fix compiler warning about sign changing
ClosedPublic

Authored by spectral on Jan 16 2020, 3:39 PM.

Details

Reviewers
mharbison72
Group Reviewers
hg-reviewers
Commits
rHG969527ac7b44: cext: fix compiler warning about sign changing
Summary

line.len is a Py_ssize_t, and we're casing to size_t (unsigned). On my compiler,
this causes a warning to be emitted:

mercurial/cext/manifest.c: In function 'pathlen':
mercurial/cext/manifest.c:48:44: warning: operand of ?: changes signedness from 'Py_ssize_t' {aka 'long int'} to 'long unsigned int' due to unsignedness of other operand [-Wsign-compare]
  return (end) ? (size_t)(end - l->start) : l->len;
                                            ^~~~~~

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

spectral created this revision.Jan 16 2020, 3:39 PM
mharbison72 accepted this revision.Jan 16 2020, 8:03 PM
mharbison72 added a subscriber: mharbison72.

LGTM

yuja added a subscriber: yuja.Jan 17 2020, 7:14 AM

static PyObject *hashflags(line *l)
{

	char *s = l->start;
  • size_t plen = pathlen(l);

+ Py_ssize_t plen = pathlen(l);

We'll probably want to change hplen to Py_ssize_t as well.

spectral added a commit: rHG969527ac7b44: cext: fix compiler warning about sign changing.Jan 17 2020, 7:21 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG969527ac7b44: cext: fix compiler warning about sign changing (authored by spectral). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/cext/manifest.c (12 lines)

Diff 19406

mercurial/cext/manifest.c

#define MANIFEST_OOM -1 #define MANIFEST_OOM -1
#define MANIFEST_NOT_SORTED -2 #define MANIFEST_NOT_SORTED -2
#define MANIFEST_MALFORMED -3 #define MANIFEST_MALFORMED -3
#define MANIFEST_BOGUS_FILENAME -4 #define MANIFEST_BOGUS_FILENAME -4
#define MANIFEST_TOO_SHORT_LINE -5 #define MANIFEST_TOO_SHORT_LINE -5
/* get the length of the path for a line */ /* get the length of the path for a line */
static size_t pathlen(line *l) static Py_ssize_t pathlen(line *l)
{ {
const char *end = memchr(l->start, '\0', l->len); const char *end = memchr(l->start, '\0', l->len);
return (end) ? (size_t)(end - l->start) : l->len; return (end) ? (Py_ssize_t)(end - l->start) : l->len;
} }
/* get the node value of a single line */ /* get the node value of a single line */
static PyObject *nodeof(line *l) static PyObject *nodeof(line *l)
{ {
char *s = l->start; char *s = l->start;
ssize_t llen = pathlen(l); Py_ssize_t llen = pathlen(l);
PyObject *hash; PyObject *hash;
if (llen + 1 + 40 + 1 > l->len) { /* path '\0' hash '\n' */ if (llen + 1 + 40 + 1 > l->len) { /* path '\0' hash '\n' */
PyErr_SetString(PyExc_ValueError, "manifest line too short"); PyErr_SetString(PyExc_ValueError, "manifest line too short");
return NULL; return NULL;
} }
hash = unhexlify(s + llen + 1, 40); hash = unhexlify(s + llen + 1, 40);
if (!hash) { if (!hash) {
return NULL; return NULL;
} }
if (l->hash_suffix != '\0') { if (l->hash_suffix != '\0') {
char newhash[21]; char newhash[21];
memcpy(newhash, PyBytes_AsString(hash), 20); memcpy(newhash, PyBytes_AsString(hash), 20);
Py_DECREF(hash); Py_DECREF(hash);
newhash[20] = l->hash_suffix; newhash[20] = l->hash_suffix;
hash = PyBytes_FromStringAndSize(newhash, 21); hash = PyBytes_FromStringAndSize(newhash, 21);
} }
return hash; return hash;
} }
/* get the node hash and flags of a line as a tuple */ /* get the node hash and flags of a line as a tuple */
static PyObject *hashflags(line *l) static PyObject *hashflags(line *l)
{ {
char *s = l->start; char *s = l->start;
size_t plen = pathlen(l); Py_ssize_t plen = pathlen(l);
PyObject *hash = nodeof(l); PyObject *hash = nodeof(l);
/* 40 for hash, 1 for null byte, 1 for newline */ /* 40 for hash, 1 for null byte, 1 for newline */
size_t hplen = plen + 42; size_t hplen = plen + 42;
Py_ssize_t flen = l->len - hplen; Py_ssize_t flen = l->len - hplen;
PyObject *flags; PyObject *flags;
PyObject *tup; PyObject *tup;
} }
/* skip over deleted manifest entries */ /* skip over deleted manifest entries */
} while (self->m->lines[self->pos].deleted); } while (self->m->lines[self->pos].deleted);
return self->m->lines + self->pos; return self->m->lines + self->pos;
} }
static PyObject *lmiter_iterentriesnext(PyObject *o) static PyObject *lmiter_iterentriesnext(PyObject *o)
{ {
size_t pl; Py_ssize_t pl;
line *l; line *l;
Py_ssize_t consumed; Py_ssize_t consumed;
PyObject *ret = NULL, *path = NULL, *hash = NULL, *flags = NULL; PyObject *ret = NULL, *path = NULL, *hash = NULL, *flags = NULL;
l = lmiter_nextline((lmIter *)o); l = lmiter_nextline((lmIter *)o);
if (!l) { if (!l) {
goto done; goto done;
} }
pl = pathlen(l); pl = pathlen(l);
0, /* tp_richcompare */ 0, /* tp_richcompare */
0, /* tp_weaklistoffset */ 0, /* tp_weaklistoffset */
PyObject_SelfIter, /* tp_iter: __iter__() method */ PyObject_SelfIter, /* tp_iter: __iter__() method */
lmiter_iterentriesnext, /* tp_iternext: next() method */ lmiter_iterentriesnext, /* tp_iternext: next() method */
}; };
static PyObject *lmiter_iterkeysnext(PyObject *o) static PyObject *lmiter_iterkeysnext(PyObject *o)
{ {
size_t pl; Py_ssize_t pl;
line *l = lmiter_nextline((lmIter *)o); line *l = lmiter_nextline((lmIter *)o);
if (!l) { if (!l) {
return NULL; return NULL;
} }
pl = pathlen(l); pl = pathlen(l);
return PyBytes_FromStringAndSize(l->start, pl); return PyBytes_FromStringAndSize(l->start, pl);
} }