This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2178

pathencode: allow clang-format oversight
ClosedPublic

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

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG44cb058bc0d3: pathencode: allow clang-format oversight
Summary

Only had to add two trailing commas to make the file format acceptably!

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 accepted this revision.Feb 12 2018, 2:15 PM
indygreg added a subscriber: indygreg.
indygreg added inline comments.
mercurial/cext/pathencode.c
129–130

I actually prefer the old style. But the good thing about using clang-format is we can bikeshed on the style later and mass rewrite things after that debate has concluded with minimal effort. So getting things to clang format is the important goal here, not bikeshedding about the style it is using today.

283–284

/me screams

This revision is now accepted and ready to land.Feb 12 2018, 2:15 PM
Closed by commit rHG44cb058bc0d3: pathencode: allow clang-format oversight (authored by durin42). · Explain WhyFeb 12 2018, 2:23 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 5488

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.c
mercurial/cext/charencode.h mercurial/cext/charencode.h
mercurial/cext/diffhelpers.c mercurial/cext/diffhelpers.c
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/pathencode.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
contrib/python-zstandard/c-ext/compressionparams.c contrib/python-zstandard/c-ext/compressionparams.c
contrib/python-zstandard/c-ext/compressionwriter.c contrib/python-zstandard/c-ext/compressionwriter.c
contrib/python-zstandard/c-ext/compressobj.c contrib/python-zstandard/c-ext/compressobj.c
contrib/python-zstandard/c-ext/compressor.c contrib/python-zstandard/c-ext/compressor.c

mercurial/cext/pathencode.c

#include <ctype.h> #include <ctype.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "util.h" #include "util.h"
/* state machine for the fast path */ /* state machine for the fast path */
enum path_state { enum path_state {
START, /* first byte of a path component */ START, /* first byte of a path component */
A, /* "AUX" */ A, /* "AUX" */
AU, AU,
THIRD, /* third of a 3-byte sequence, e.g. "AUX", "NUL" */ THIRD, /* third of a 3-byte sequence, e.g. "AUX", "NUL" */
C, /* "CON" or "COMn" */ C, /* "CON" or "COMn" */
CO, CO,
COMLPT, /* "COM" or "LPT" */ COMLPT, /* "COM" or "LPT" */
COMLPTn, COMLPTn,
L, L,
LP, LP,
N, N,
NU, NU,
P, /* "PRN" */ P, /* "PRN" */
PR, PR,
LDOT, /* leading '.' */ LDOT, /* leading '.' */
DOT, /* '.' in a non-leading position */ DOT, /* '.' in a non-leading position */
H, /* ".h" */ H, /* ".h" */
HGDI, /* ".hg", ".d", or ".i" */ HGDI, /* ".hg", ".d", or ".i" */
SPACE, SPACE,
DEFAULT /* byte of a path component after the first */ DEFAULT, /* byte of a path component after the first */
}; };
/* state machine for dir-encoding */ /* state machine for dir-encoding */
enum dir_state { enum dir_state {
DDOT, DDOT,
DH, DH,
DHGDI, DHGDI,
DDEFAULT DDEFAULT,
}; };
static inline int inset(const uint32_t bitset[], char c) static inline int inset(const uint32_t bitset[], char c)
{ {
return bitset[((uint8_t)c) >> 5] & (1 << (((uint8_t)c) & 31)); return bitset[((uint8_t)c) >> 5] & (1 << (((uint8_t)c) & 31));
} }
static inline void charcopy(char *dest, Py_ssize_t *destlen, size_t destsize, static inline void charcopy(char *dest, Py_ssize_t *destlen, size_t destsize,
if (dest) { if (dest) {
assert(*destlen + len < destsize); assert(*destlen + len < destsize);
memcpy((void *)&dest[*destlen], src, len); memcpy((void *)&dest[*destlen], src, len);
} }
*destlen += len; *destlen += len;
} }
static inline void hexencode(char *dest, Py_ssize_t *destlen, size_t destsize, static inline void hexencode(char *dest, Py_ssize_t *destlen, size_t destsize,
uint8_t c) uint8_t c)
{ {
static const char hexdigit[] = "0123456789abcdef"; static const char hexdigit[] = "0123456789abcdef";
charcopy(dest, destlen, destsize, hexdigit[c >> 4]); charcopy(dest, destlen, destsize, hexdigit[c >> 4]);
charcopy(dest, destlen, destsize, hexdigit[c & 15]); charcopy(dest, destlen, destsize, hexdigit[c & 15]);
} }
/* 3-byte escape: tilde followed by two hex digits */ /* 3-byte escape: tilde followed by two hex digits */
static inline void escape3(char *dest, Py_ssize_t *destlen, size_t destsize, static inline void escape3(char *dest, Py_ssize_t *destlen, size_t destsize,
char c) char c)
{ {
charcopy(dest, destlen, destsize, '~'); charcopy(dest, destlen, destsize, '~');
hexencode(dest, destlen, destsize, c); hexencode(dest, destlen, destsize, c);
} }
static Py_ssize_t _encodedir(char *dest, size_t destsize, static Py_ssize_t _encodedir(char *dest, size_t destsize, const char *src,
const char *src, Py_ssize_t len) Py_ssize_t len)
{ {
enum dir_state state = DDEFAULT; enum dir_state state = DDEFAULT;
Py_ssize_t i = 0, destlen = 0; Py_ssize_t i = 0, destlen = 0;
while (i < len) { while (i < len) {
switch (state) { switch (state) {
case DDOT: case DDOT:
switch (src[i]) { switch (src[i]) {
state = DDEFAULT; state = DDEFAULT;
break; break;
} }
break; break;
case DH: case DH:
if (src[i] == 'g') { if (src[i] == 'g') {
state = DHGDI; state = DHGDI;
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
} } else
else state = DDEFAULT; state = DDEFAULT;
indygregUnsubmitted
Not Done

I actually prefer the old style. But the good thing about using clang-format is we can bikeshed on the style later and mass rewrite things after that debate has concluded with minimal effort. So getting things to clang format is the important goal here, not bikeshedding about the style it is using today.

indygreg: I actually prefer the old style. But the good thing about using clang-format is we can bikeshed…
break; break;
case DHGDI: case DHGDI:
if (src[i] == '/') { if (src[i] == '/') {
memcopy(dest, &destlen, destsize, ".hg", 3); memcopy(dest, &destlen, destsize, ".hg", 3);
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
} }
state = DDEFAULT; state = DDEFAULT;
break; break;
return pathobj; return pathobj;
} }
newobj = PyBytes_FromStringAndSize(NULL, newlen); newobj = PyBytes_FromStringAndSize(NULL, newlen);
if (newobj) { if (newobj) {
assert(PyBytes_Check(newobj)); assert(PyBytes_Check(newobj));
Py_SIZE(newobj)--; Py_SIZE(newobj)--;
_encodedir(PyBytes_AS_STRING(newobj), newlen, path, _encodedir(PyBytes_AS_STRING(newobj), newlen, path, len + 1);
len + 1);
} }
return newobj; return newobj;
} }
static Py_ssize_t _encode(const uint32_t twobytes[8], const uint32_t onebyte[8], static Py_ssize_t _encode(const uint32_t twobytes[8], const uint32_t onebyte[8],
char *dest, Py_ssize_t destlen, size_t destsize, char *dest, Py_ssize_t destlen, size_t destsize,
const char *src, Py_ssize_t len, const char *src, Py_ssize_t len, int encodedir)
int encodedir)
{ {
enum path_state state = START; enum path_state state = START;
Py_ssize_t i = 0; Py_ssize_t i = 0;
/* /*
* Python strings end with a zero byte, which we use as a * Python strings end with a zero byte, which we use as a
* terminal token as they are not valid inside path names. * terminal token as they are not valid inside path names.
*/ */
state = DEFAULT; state = DEFAULT;
break; break;
} }
break; break;
case A: case A:
if (src[i] == 'u') { if (src[i] == 'u') {
state = AU; state = AU;
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
} } else
else state = DEFAULT; state = DEFAULT;
break; break;
case AU: case AU:
if (src[i] == 'x') { if (src[i] == 'x') {
state = THIRD; state = THIRD;
i++; i++;
} } else
else state = DEFAULT; state = DEFAULT;
break; break;
case THIRD: case THIRD:
state = DEFAULT; state = DEFAULT;
switch (src[i]) { switch (src[i]) {
case '.': case '.':
case '/': case '/':
case '\0': case '\0':
escape3(dest, &destlen, destsize, src[i - 1]); escape3(dest, &destlen, destsize, src[i - 1]);
break; break;
default: default:
i--; i--;
break; break;
} }
break; break;
case C: case C:
if (src[i] == 'o') { if (src[i] == 'o') {
state = CO; state = CO;
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
} } else
else state = DEFAULT; state = DEFAULT;
break; break;
case CO: case CO:
if (src[i] == 'm') { if (src[i] == 'm') {
state = COMLPT; state = COMLPT;
i++; i++;
} } else if (src[i] == 'n') {
else if (src[i] == 'n') {
state = THIRD; state = THIRD;
i++; i++;
} } else
else state = DEFAULT; state = DEFAULT;
break; break;
case COMLPT: case COMLPT:
switch (src[i]) { switch (src[i]) {
case '1': case '2': case '3': case '4': case '5': case '1':
case '6': case '7': case '8': case '9': case '2':
indygregUnsubmitted
Not Done

/me screams

indygreg: /me screams
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
state = COMLPTn; state = COMLPTn;
i++; i++;
break; break;
default: default:
state = DEFAULT; state = DEFAULT;
charcopy(dest, &destlen, destsize, src[i - 1]); charcopy(dest, &destlen, destsize, src[i - 1]);
break; break;
} }
break; break;
case COMLPTn: case COMLPTn:
state = DEFAULT; state = DEFAULT;
switch (src[i]) { switch (src[i]) {
case '.': case '.':
case '/': case '/':
case '\0': case '\0':
escape3(dest, &destlen, destsize, src[i - 2]); escape3(dest, &destlen, destsize, src[i - 2]);
charcopy(dest, &destlen, destsize, src[i - 1]); charcopy(dest, &destlen, destsize, src[i - 1]);
break; break;
default: default:
memcopy(dest, &destlen, destsize, memcopy(dest, &destlen, destsize, &src[i - 2],
&src[i - 2], 2); 2);
break; break;
} }
break; break;
case L: case L:
if (src[i] == 'p') { if (src[i] == 'p') {
state = LP; state = LP;
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
} } else
else state = DEFAULT; state = DEFAULT;
break; break;
case LP: case LP:
if (src[i] == 't') { if (src[i] == 't') {
state = COMLPT; state = COMLPT;
i++; i++;
} } else
else state = DEFAULT; state = DEFAULT;
break; break;
case N: case N:
if (src[i] == 'u') { if (src[i] == 'u') {
state = NU; state = NU;
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
} } else
else state = DEFAULT; state = DEFAULT;
break; break;
case NU: case NU:
if (src[i] == 'l') { if (src[i] == 'l') {
state = THIRD; state = THIRD;
i++; i++;
} } else
else state = DEFAULT; state = DEFAULT;
break; break;
case P: case P:
if (src[i] == 'r') { if (src[i] == 'r') {
state = PR; state = PR;
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
} } else
else state = DEFAULT; state = DEFAULT;
break; break;
case PR: case PR:
if (src[i] == 'n') { if (src[i] == 'n') {
state = THIRD; state = THIRD;
i++; i++;
} } else
else state = DEFAULT; state = DEFAULT;
break; break;
case LDOT: case LDOT:
switch (src[i]) { switch (src[i]) {
case 'd': case 'd':
case 'i': case 'i':
state = HGDI; state = HGDI;
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
break; break;
charcopy(dest, &destlen, destsize, '.'); charcopy(dest, &destlen, destsize, '.');
break; break;
} }
break; break;
case H: case H:
if (src[i] == 'g') { if (src[i] == 'g') {
state = HGDI; state = HGDI;
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
} } else
else state = DEFAULT; state = DEFAULT;
break; break;
case HGDI: case HGDI:
if (src[i] == '/') { if (src[i] == '/') {
state = START; state = START;
if (encodedir) if (encodedir)
memcopy(dest, &destlen, destsize, ".hg", memcopy(dest, &destlen, destsize, ".hg",
3); 3);
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
} } else
else state = DEFAULT; state = DEFAULT;
break; break;
case SPACE: case SPACE:
switch (src[i]) { switch (src[i]) {
case '/': case '/':
case '\0': case '\0':
state = START; state = START;
memcopy(dest, &destlen, destsize, "~20", 3); memcopy(dest, &destlen, destsize, "~20", 3);
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
state = START; state = START;
charcopy(dest, &destlen, destsize, '/'); charcopy(dest, &destlen, destsize, '/');
i++; i++;
break; break;
default: default:
if (inset(onebyte, src[i])) { if (inset(onebyte, src[i])) {
do { do {
charcopy(dest, &destlen, charcopy(dest, &destlen,
destsize, src[i++]); destsize, src[i++]);
} while (i < len && } while (i < len &&
inset(onebyte, src[i])); inset(onebyte, src[i]));
} } else if (inset(twobytes, src[i])) {
else if (inset(twobytes, src[i])) {
char c = src[i++]; char c = src[i++];
charcopy(dest, &destlen, destsize, '_'); charcopy(dest, &destlen, destsize, '_');
charcopy(dest, &destlen, destsize, charcopy(dest, &destlen, destsize,
c == '_' ? '_' : c + 32); c == '_' ? '_' : c + 32);
} } else
else
escape3(dest, &destlen, destsize, escape3(dest, &destlen, destsize,
src[i++]); src[i++]);
break; break;
} }
break; break;
} }
} }
done: done:
return destlen; return destlen;
} }
static Py_ssize_t basicencode(char *dest, size_t destsize, static Py_ssize_t basicencode(char *dest, size_t destsize, const char *src,
const char *src, Py_ssize_t len) Py_ssize_t len)
{ {
static const uint32_t twobytes[8] = { 0, 0, 0x87fffffe }; static const uint32_t twobytes[8] = {0, 0, 0x87fffffe};
static const uint32_t onebyte[8] = { static const uint32_t onebyte[8] = {
1, 0x2bff3bfa, 0x68000001, 0x2fffffff, 1, 0x2bff3bfa, 0x68000001, 0x2fffffff,
}; };
Py_ssize_t destlen = 0; Py_ssize_t destlen = 0;
return _encode(twobytes, onebyte, dest, destlen, destsize, return _encode(twobytes, onebyte, dest, destlen, destsize, src, len, 1);
src, len, 1);
} }
static const Py_ssize_t maxstorepathlen = 120; static const Py_ssize_t maxstorepathlen = 120;
static Py_ssize_t _lowerencode(char *dest, size_t destsize, static Py_ssize_t _lowerencode(char *dest, size_t destsize, const char *src,
const char *src, Py_ssize_t len) Py_ssize_t len)
{ {
static const uint32_t onebyte[8] = { static const uint32_t onebyte[8] = {1, 0x2bfffbfb, 0xe8000001,
1, 0x2bfffbfb, 0xe8000001, 0x2fffffff 0x2fffffff};
};
static const uint32_t lower[8] = { 0, 0, 0x7fffffe }; static const uint32_t lower[8] = {0, 0, 0x7fffffe};
Py_ssize_t i, destlen = 0; Py_ssize_t i, destlen = 0;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
if (inset(onebyte, src[i])) if (inset(onebyte, src[i]))
charcopy(dest, &destlen, destsize, src[i]); charcopy(dest, &destlen, destsize, src[i]);
else if (inset(lower, src[i])) else if (inset(lower, src[i]))
charcopy(dest, &destlen, destsize, src[i] + 32); charcopy(dest, &destlen, destsize, src[i] + 32);
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);
return ret; return ret;
} }
/* See store.py:_auxencode for a description. */ /* See store.py:_auxencode for a description. */
static Py_ssize_t auxencode(char *dest, size_t destsize, static Py_ssize_t auxencode(char *dest, size_t destsize, const char *src,
const char *src, Py_ssize_t len) Py_ssize_t len)
{ {
static const uint32_t twobytes[8]; static const uint32_t twobytes[8];
static const uint32_t onebyte[8] = { static const uint32_t onebyte[8] = {
~0U, 0xffff3ffe, ~0U, ~0U, ~0U, ~0U, ~0U, ~0U, ~0U, 0xffff3ffe, ~0U, ~0U, ~0U, ~0U, ~0U, ~0U,
}; };
return _encode(twobytes, onebyte, dest, 0, destsize, src, len, 0); return _encode(twobytes, onebyte, dest, 0, destsize, src, len, 0);
} }
static PyObject *hashmangle(const char *src, Py_ssize_t len, const char sha[20]) static PyObject *hashmangle(const char *src, Py_ssize_t len, const char sha[20])
{ {
static const Py_ssize_t dirprefixlen = 8; static const Py_ssize_t dirprefixlen = 8;
in a space or dot, which are unportable. */ in a space or dot, which are unportable. */
if (d == '.' || d == ' ') if (d == '.' || d == ' ')
dest[destlen - 1] = '_'; dest[destlen - 1] = '_';
/* The + 3 is to account for "dh/" in the beginning */ /* The + 3 is to account for "dh/" in the beginning */
if (destlen > maxshortdirslen + 3) if (destlen > maxshortdirslen + 3)
break; break;
charcopy(dest, &destlen, destsize, src[i]); charcopy(dest, &destlen, destsize, src[i]);
p = -1; p = -1;
} } else if (p < dirprefixlen)
else if (p < dirprefixlen)
charcopy(dest, &destlen, destsize, src[i]); charcopy(dest, &destlen, destsize, src[i]);
} }
/* Rewind to just before the last slash copied. */ /* Rewind to just before the last slash copied. */
if (destlen > maxshortdirslen + 3) if (destlen > maxshortdirslen + 3)
do { do {
destlen--; destlen--;
} while (destlen > 0 && dest[destlen] != '/'); } while (destlen > 0 && dest[destlen] != '/');
depends on the number of bytes left after accounting for depends on the number of bytes left after accounting for
hash and suffix. */ hash and suffix. */
used = destlen + 40; used = destlen + 40;
if (lastdot >= 0) if (lastdot >= 0)
used += len - lastdot - 1; used += len - lastdot - 1;
slop = maxstorepathlen - used; slop = maxstorepathlen - used;
if (slop > 0) { if (slop > 0) {
Py_ssize_t basenamelen = Py_ssize_t basenamelen =
lastslash >= 0 ? len - lastslash - 2 : len - 1; lastslash >= 0 ? len - lastslash - 2 : len - 1;
if (basenamelen > slop) if (basenamelen > slop)
basenamelen = slop; basenamelen = slop;
if (basenamelen > 0) if (basenamelen > 0)
memcopy(dest, &destlen, destsize, &src[lastslash + 1], memcopy(dest, &destlen, destsize, &src[lastslash + 1],
basenamelen); basenamelen);
} }
/* Add hash and suffix. */ /* Add hash and suffix. */
for (i = 0; i < 20; i++) for (i = 0; i < 20; i++)
hexencode(dest, &destlen, destsize, sha[i]); hexencode(dest, &destlen, destsize, sha[i]);
if (lastdot >= 0) if (lastdot >= 0)
memcopy(dest, &destlen, destsize, &src[lastdot], memcopy(dest, &destlen, destsize, &src[lastdot],
len - lastdot - 1); len - lastdot - 1);
assert(PyBytes_Check(ret)); assert(PyBytes_Check(ret));
Py_SIZE(ret) = destlen; Py_SIZE(ret) = destlen;
return ret; return ret;
} }
/* /*
PyErr_SetString(PyExc_ImportError, "hashlib"); PyErr_SetString(PyExc_ImportError, "hashlib");
return -1; return -1;
} }
shafunc = PyObject_GetAttrString(hashlib, "sha1"); shafunc = PyObject_GetAttrString(hashlib, "sha1");
Py_DECREF(hashlib); Py_DECREF(hashlib);
if (shafunc == NULL) { if (shafunc == NULL) {
PyErr_SetString(PyExc_AttributeError, PyErr_SetString(PyExc_AttributeError,
"module 'hashlib' has no " "module 'hashlib' has no "
"attribute 'sha1'"); "attribute 'sha1'");
return -1; return -1;
} }
} }
shaobj = PyObject_CallFunction(shafunc, "s#", str, len); shaobj = PyObject_CallFunction(shafunc, "s#", 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)
return -1; return -1;
if (!PyBytes_Check(hashobj) || PyBytes_GET_SIZE(hashobj) != 20) { if (!PyBytes_Check(hashobj) || PyBytes_GET_SIZE(hashobj) != 20) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"result of digest is not a 20-byte hash"); "result of digest is not a 20-byte hash");
Py_DECREF(hashobj); Py_DECREF(hashobj);
return -1; return -1;
} }
memcpy(hash, PyBytes_AS_STRING(hashobj), 20); memcpy(hash, PyBytes_AS_STRING(hashobj), 20);
Py_DECREF(hashobj); Py_DECREF(hashobj);
return 0; return 0;
} }
} }
newobj = PyBytes_FromStringAndSize(NULL, newlen); newobj = PyBytes_FromStringAndSize(NULL, newlen);
if (newobj) { if (newobj) {
assert(PyBytes_Check(newobj)); assert(PyBytes_Check(newobj));
Py_SIZE(newobj)--; Py_SIZE(newobj)--;
basicencode(PyBytes_AS_STRING(newobj), newlen, path, basicencode(PyBytes_AS_STRING(newobj), newlen, path,
len + 1); len + 1);
} }
} } else
else
newobj = hashencode(path, len + 1); newobj = hashencode(path, len + 1);
return newobj; return newobj;
} }