This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5675

cleanup: use clang-tidy to add missing {} around one-line statements
ClosedPublic

Authored by durin42 on Jan 24 2019, 10:22 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG763b45bc4483: cleanup: use clang-tidy to add missing {} around one-line statements
Summary

I find this easier to read. Cleanup performed like this:

hg files 'set:(.c or .cc or **.h) and not "listfile:contrib/clang-format-ignorelist"' | while read f ; do

clang-tidy -fix -checks=readability-braces-around-statements $f -- $(python-config --cflags) -Imercurial/cext -Imercurial

done
make format-c

I had to revert chg/chg.c as it's got a construct that seems to confuse
clang-tidy, so I'll work on that file later if this change is acceptable. I
only tackle files that are under clang-format's authority because otherwise
I'd have to do a bunch of manual formatting. A few files didn't get edited
because clang-tidy couldn't find some headers. Again, I'll figure that out
later assuming this change is accepted.

No check-code rule added for now because writing the regex sounds hard. In a
perfect world I guess we could write a test that uses clang-tidy on these
files, but I think clang-tidy is pretty rarely installed. :/

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

durin42 created this revision.Jan 24 2019, 10:22 AM
durin42 edited the summary of this revision. (Show Details)Jan 24 2019, 10:27 AM
durin42 updated this revision to Diff 13395.
pulkit accepted this revision.Jan 24 2019, 11:52 AM
Closed by commit rHG763b45bc4483: cleanup: use clang-tidy to add missing {} around one-line statements (authored by durin42). · Explain WhyJan 24 2019, 12:03 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 13404

contrib/chg/hgclient.c

ctx->data = malloc(defaultdatasize); ctx->data = malloc(defaultdatasize);
ctx->maxdatasize = (ctx->data) ? defaultdatasize : 0; ctx->maxdatasize = (ctx->data) ? defaultdatasize : 0;
ctx->datasize = 0; ctx->datasize = 0;
debugmsg("initialize context buffer with size %zu", ctx->maxdatasize); debugmsg("initialize context buffer with size %zu", ctx->maxdatasize);
} }
static void enlargecontext(context_t *ctx, size_t newsize) static void enlargecontext(context_t *ctx, size_t newsize)
{ {
if (newsize <= ctx->maxdatasize) if (newsize <= ctx->maxdatasize) {
return; return;
}
newsize = defaultdatasize * newsize = defaultdatasize *
((newsize + defaultdatasize - 1) / defaultdatasize); ((newsize + defaultdatasize - 1) / defaultdatasize);
ctx->data = reallocx(ctx->data, newsize); ctx->data = reallocx(ctx->data, newsize);
ctx->maxdatasize = newsize; ctx->maxdatasize = newsize;
debugmsg("enlarge context buffer to %zu", ctx->maxdatasize); debugmsg("enlarge context buffer to %zu", ctx->maxdatasize);
} }
if (rsize != sizeof(hgc->ctx.ch)) { if (rsize != sizeof(hgc->ctx.ch)) {
/* server would have exception and traceback would be printed */ /* server would have exception and traceback would be printed */
debugmsg("failed to read channel"); debugmsg("failed to read channel");
exit(255); exit(255);
} }
uint32_t datasize_n; uint32_t datasize_n;
rsize = recv(hgc->sockfd, &datasize_n, sizeof(datasize_n), 0); rsize = recv(hgc->sockfd, &datasize_n, sizeof(datasize_n), 0);
if (rsize != sizeof(datasize_n)) if (rsize != sizeof(datasize_n)) {
abortmsg("failed to read data size"); abortmsg("failed to read data size");
}
/* datasize denotes the maximum size to write if input request */ /* datasize denotes the maximum size to write if input request */
hgc->ctx.datasize = ntohl(datasize_n); hgc->ctx.datasize = ntohl(datasize_n);
enlargecontext(&hgc->ctx, hgc->ctx.datasize); enlargecontext(&hgc->ctx, hgc->ctx.datasize);
if (isupper(hgc->ctx.ch) && hgc->ctx.ch != 'S') if (isupper(hgc->ctx.ch) && hgc->ctx.ch != 'S') {
return; /* assumes input request */ return; /* assumes input request */
}
size_t cursize = 0; size_t cursize = 0;
while (cursize < hgc->ctx.datasize) { while (cursize < hgc->ctx.datasize) {
rsize = recv(hgc->sockfd, hgc->ctx.data + cursize, rsize = recv(hgc->sockfd, hgc->ctx.data + cursize,
hgc->ctx.datasize - cursize, 0); hgc->ctx.datasize - cursize, 0);
if (rsize < 1) if (rsize < 1) {
abortmsg("failed to read data block"); abortmsg("failed to read data block");
}
cursize += rsize; cursize += rsize;
} }
} }
static void sendall(int sockfd, const void *data, size_t datasize) static void sendall(int sockfd, const void *data, size_t datasize)
{ {
const char *p = data; const char *p = data;
const char *const endp = p + datasize; const char *const endp = p + datasize;
while (p < endp) { while (p < endp) {
ssize_t r = send(sockfd, p, endp - p, 0); ssize_t r = send(sockfd, p, endp - p, 0);
if (r < 0) if (r < 0) {
abortmsgerrno("cannot communicate"); abortmsgerrno("cannot communicate");
}
p += r; p += r;
} }
} }
/* Write lengh-data block to cmdserver */ /* Write lengh-data block to cmdserver */
static void writeblock(const hgclient_t *hgc) static void writeblock(const hgclient_t *hgc)
{ {
assert(hgc); assert(hgc);
const char *const *const end = (argsize >= 0) ? args + argsize : NULL; const char *const *const end = (argsize >= 0) ? args + argsize : NULL;
for (const char *const *it = args; it != end && *it; ++it) { for (const char *const *it = args; it != end && *it; ++it) {
const size_t n = strlen(*it) + 1; /* include '\0' */ const size_t n = strlen(*it) + 1; /* include '\0' */
enlargecontext(ctx, ctx->datasize + n); enlargecontext(ctx, ctx->datasize + n);
memcpy(ctx->data + ctx->datasize, *it, n); memcpy(ctx->data + ctx->datasize, *it, n);
ctx->datasize += n; ctx->datasize += n;
} }
if (ctx->datasize > 0) if (ctx->datasize > 0) {
--ctx->datasize; /* strip last '\0' */ --ctx->datasize; /* strip last '\0' */
} }
}
/* Extract '\0'-separated list of args to new buffer, terminated by NULL */ /* Extract '\0'-separated list of args to new buffer, terminated by NULL */
static const char **unpackcmdargsnul(const context_t *ctx) static const char **unpackcmdargsnul(const context_t *ctx)
{ {
const char **args = NULL; const char **args = NULL;
size_t nargs = 0, maxnargs = 0; size_t nargs = 0, maxnargs = 0;
const char *s = ctx->data; const char *s = ctx->data;
const char *e = ctx->data + ctx->datasize; const char *e = ctx->data + ctx->datasize;
for (;;) { for (;;) {
if (nargs + 1 >= maxnargs) { /* including last NULL */ if (nargs + 1 >= maxnargs) { /* including last NULL */
maxnargs += 256; maxnargs += 256;
args = reallocx(args, maxnargs * sizeof(args[0])); args = reallocx(args, maxnargs * sizeof(args[0]));
} }
args[nargs] = s; args[nargs] = s;
nargs++; nargs++;
s = memchr(s, '\0', e - s); s = memchr(s, '\0', e - s);
if (!s) if (!s) {
break; break;
}
s++; s++;
} }
args[nargs] = NULL; args[nargs] = NULL;
return args; return args;
} }
static void handlereadrequest(hgclient_t *hgc) static void handlereadrequest(hgclient_t *hgc)
{ {
context_t *ctx = &hgc->ctx; context_t *ctx = &hgc->ctx;
size_t r = fread(ctx->data, sizeof(ctx->data[0]), ctx->datasize, stdin); size_t r = fread(ctx->data, sizeof(ctx->data[0]), ctx->datasize, stdin);
ctx->datasize = r; ctx->datasize = r;
writeblock(hgc); writeblock(hgc);
} }
/* Read single-line */ /* Read single-line */
static void handlereadlinerequest(hgclient_t *hgc) static void handlereadlinerequest(hgclient_t *hgc)
{ {
context_t *ctx = &hgc->ctx; context_t *ctx = &hgc->ctx;
if (!fgets(ctx->data, ctx->datasize, stdin)) if (!fgets(ctx->data, ctx->datasize, stdin)) {
ctx->data[0] = '\0'; ctx->data[0] = '\0';
}
ctx->datasize = strlen(ctx->data); ctx->datasize = strlen(ctx->data);
writeblock(hgc); writeblock(hgc);
} }
/* Execute the requested command and write exit code */ /* Execute the requested command and write exit code */
static void handlesystemrequest(hgclient_t *hgc) static void handlesystemrequest(hgclient_t *hgc)
{ {
context_t *ctx = &hgc->ctx; context_t *ctx = &hgc->ctx;
enlargecontext(ctx, ctx->datasize + 1); enlargecontext(ctx, ctx->datasize + 1);
ctx->data[ctx->datasize] = '\0'; /* terminate last string */ ctx->data[ctx->datasize] = '\0'; /* terminate last string */
const char **args = unpackcmdargsnul(ctx); const char **args = unpackcmdargsnul(ctx);
if (!args[0] || !args[1] || !args[2]) if (!args[0] || !args[1] || !args[2]) {
abortmsg("missing type or command or cwd in system request"); abortmsg("missing type or command or cwd in system request");
}
if (strcmp(args[0], "system") == 0) { if (strcmp(args[0], "system") == 0) {
debugmsg("run '%s' at '%s'", args[1], args[2]); debugmsg("run '%s' at '%s'", args[1], args[2]);
int32_t r = runshellcmd(args[1], args + 3, args[2]); int32_t r = runshellcmd(args[1], args + 3, args[2]);
free(args); free(args);
uint32_t r_n = htonl(r); uint32_t r_n = htonl(r);
memcpy(ctx->data, &r_n, sizeof(r_n)); memcpy(ctx->data, &r_n, sizeof(r_n));
ctx->datasize = sizeof(r_n); ctx->datasize = sizeof(r_n);
writeblock(hgc); writeblock(hgc);
} else if (strcmp(args[0], "pager") == 0) { } else if (strcmp(args[0], "pager") == 0) {
setuppager(args[1], args + 3); setuppager(args[1], args + 3);
if (hgc->capflags & CAP_ATTACHIO) if (hgc->capflags & CAP_ATTACHIO) {
attachio(hgc); attachio(hgc);
}
/* unblock the server */ /* unblock the server */
static const char emptycmd[] = "\n"; static const char emptycmd[] = "\n";
sendall(hgc->sockfd, emptycmd, sizeof(emptycmd) - 1); sendall(hgc->sockfd, emptycmd, sizeof(emptycmd) - 1);
} else { } else {
abortmsg("unknown type in system request: %s", args[0]); abortmsg("unknown type in system request: %s", args[0]);
} }
} }
break; break;
case 'L': case 'L':
handlereadlinerequest(hgc); handlereadlinerequest(hgc);
break; break;
case 'S': case 'S':
handlesystemrequest(hgc); handlesystemrequest(hgc);
break; break;
default: default:
if (isupper(ctx->ch)) if (isupper(ctx->ch)) {
abortmsg("cannot handle response (ch = %c)", abortmsg("cannot handle response (ch = %c)",
ctx->ch); ctx->ch);
} }
} }
} }
}
static unsigned int parsecapabilities(const char *s, const char *e) static unsigned int parsecapabilities(const char *s, const char *e)
{ {
unsigned int flags = 0; unsigned int flags = 0;
while (s < e) { while (s < e) {
const char *t = strchr(s, ' '); const char *t = strchr(s, ' ');
if (!t || t > e) if (!t || t > e) {
t = e; t = e;
}
const cappair_t *cap; const cappair_t *cap;
for (cap = captable; cap->flag; ++cap) { for (cap = captable; cap->flag; ++cap) {
size_t n = t - s; size_t n = t - s;
if (strncmp(s, cap->name, n) == 0 && if (strncmp(s, cap->name, n) == 0 &&
strlen(cap->name) == n) { strlen(cap->name) == n) {
flags |= cap->flag; flags |= cap->flag;
break; break;
} }
enlargecontext(ctx, ctx->datasize + 1); enlargecontext(ctx, ctx->datasize + 1);
ctx->data[ctx->datasize] = '\0'; ctx->data[ctx->datasize] = '\0';
debugmsg("hello received: %s (size = %zu)", ctx->data, ctx->datasize); debugmsg("hello received: %s (size = %zu)", ctx->data, ctx->datasize);
const char *s = ctx->data; const char *s = ctx->data;
const char *const dataend = ctx->data + ctx->datasize; const char *const dataend = ctx->data + ctx->datasize;
while (s < dataend) { while (s < dataend) {
const char *t = strchr(s, ':'); const char *t = strchr(s, ':');
if (!t || t[1] != ' ') if (!t || t[1] != ' ') {
break; break;
}
const char *u = strchr(t + 2, '\n'); const char *u = strchr(t + 2, '\n');
if (!u) if (!u) {
u = dataend; u = dataend;
}
if (strncmp(s, "capabilities:", t - s + 1) == 0) { if (strncmp(s, "capabilities:", t - s + 1) == 0) {
hgc->capflags = parsecapabilities(t + 2, u); hgc->capflags = parsecapabilities(t + 2, u);
} else if (strncmp(s, "pgid:", t - s + 1) == 0) { } else if (strncmp(s, "pgid:", t - s + 1) == 0) {
hgc->pgid = strtol(t + 2, NULL, 10); hgc->pgid = strtol(t + 2, NULL, 10);
} else if (strncmp(s, "pid:", t - s + 1) == 0) { } else if (strncmp(s, "pid:", t - s + 1) == 0) {
hgc->pid = strtol(t + 2, NULL, 10); hgc->pid = strtol(t + 2, NULL, 10);
} }
s = u + 1; s = u + 1;
} }
debugmsg("capflags=0x%04x, pid=%d", hgc->capflags, hgc->pid); debugmsg("capflags=0x%04x, pid=%d", hgc->capflags, hgc->pid);
} }
static void updateprocname(hgclient_t *hgc) static void updateprocname(hgclient_t *hgc)
{ {
int r = snprintf(hgc->ctx.data, hgc->ctx.maxdatasize, "chg[worker/%d]", int r = snprintf(hgc->ctx.data, hgc->ctx.maxdatasize, "chg[worker/%d]",
(int)getpid()); (int)getpid());
if (r < 0 || (size_t)r >= hgc->ctx.maxdatasize) if (r < 0 || (size_t)r >= hgc->ctx.maxdatasize) {
abortmsg("insufficient buffer to write procname (r = %d)", r); abortmsg("insufficient buffer to write procname (r = %d)", r);
}
hgc->ctx.datasize = (size_t)r; hgc->ctx.datasize = (size_t)r;
writeblockrequest(hgc, "setprocname"); writeblockrequest(hgc, "setprocname");
} }
static void attachio(hgclient_t *hgc) static void attachio(hgclient_t *hgc)
{ {
debugmsg("request attachio"); debugmsg("request attachio");
static const char chcmd[] = "attachio\n"; static const char chcmd[] = "attachio\n";
sendall(hgc->sockfd, chcmd, sizeof(chcmd) - 1); sendall(hgc->sockfd, chcmd, sizeof(chcmd) - 1);
readchannel(hgc); readchannel(hgc);
context_t *ctx = &hgc->ctx; context_t *ctx = &hgc->ctx;
if (ctx->ch != 'I') if (ctx->ch != 'I') {
abortmsg("unexpected response for attachio (ch = %c)", ctx->ch); abortmsg("unexpected response for attachio (ch = %c)", ctx->ch);
}
static const int fds[3] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO}; static const int fds[3] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};
struct msghdr msgh; struct msghdr msgh;
memset(&msgh, 0, sizeof(msgh)); memset(&msgh, 0, sizeof(msgh));
struct iovec iov = {ctx->data, ctx->datasize}; /* dummy payload */ struct iovec iov = {ctx->data, ctx->datasize}; /* dummy payload */
msgh.msg_iov = &iov; msgh.msg_iov = &iov;
msgh.msg_iovlen = 1; msgh.msg_iovlen = 1;
char fdbuf[CMSG_SPACE(sizeof(fds))]; char fdbuf[CMSG_SPACE(sizeof(fds))];
msgh.msg_control = fdbuf; msgh.msg_control = fdbuf;
msgh.msg_controllen = sizeof(fdbuf); msgh.msg_controllen = sizeof(fdbuf);
struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msgh); struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msgh);
cmsg->cmsg_level = SOL_SOCKET; cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS; cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(sizeof(fds)); cmsg->cmsg_len = CMSG_LEN(sizeof(fds));
memcpy(CMSG_DATA(cmsg), fds, sizeof(fds)); memcpy(CMSG_DATA(cmsg), fds, sizeof(fds));
msgh.msg_controllen = cmsg->cmsg_len; msgh.msg_controllen = cmsg->cmsg_len;
ssize_t r = sendmsg(hgc->sockfd, &msgh, 0); ssize_t r = sendmsg(hgc->sockfd, &msgh, 0);
if (r < 0) if (r < 0) {
abortmsgerrno("sendmsg failed"); abortmsgerrno("sendmsg failed");
}
handleresponse(hgc); handleresponse(hgc);
int32_t n; int32_t n;
if (ctx->datasize != sizeof(n)) if (ctx->datasize != sizeof(n)) {
abortmsg("unexpected size of attachio result"); abortmsg("unexpected size of attachio result");
}
memcpy(&n, ctx->data, sizeof(n)); memcpy(&n, ctx->data, sizeof(n));
n = ntohl(n); n = ntohl(n);
if (n != sizeof(fds) / sizeof(fds[0])) if (n != sizeof(fds) / sizeof(fds[0])) {
abortmsg("failed to send fds (n = %d)", n); abortmsg("failed to send fds (n = %d)", n);
} }
}
static void chdirtocwd(hgclient_t *hgc) static void chdirtocwd(hgclient_t *hgc)
{ {
if (!getcwd(hgc->ctx.data, hgc->ctx.maxdatasize)) if (!getcwd(hgc->ctx.data, hgc->ctx.maxdatasize)) {
abortmsgerrno("failed to getcwd"); abortmsgerrno("failed to getcwd");
}
hgc->ctx.datasize = strlen(hgc->ctx.data); hgc->ctx.datasize = strlen(hgc->ctx.data);
writeblockrequest(hgc, "chdir"); writeblockrequest(hgc, "chdir");
} }
static void forwardumask(hgclient_t *hgc) static void forwardumask(hgclient_t *hgc)
{ {
mode_t mask = umask(0); mode_t mask = umask(0);
umask(mask); umask(mask);
uint32_t data = htonl(mask); uint32_t data = htonl(mask);
enlargecontext(&hgc->ctx, sizeof(data)); enlargecontext(&hgc->ctx, sizeof(data));
memcpy(hgc->ctx.data, &data, sizeof(data)); memcpy(hgc->ctx.data, &data, sizeof(data));
hgc->ctx.datasize = sizeof(data); hgc->ctx.datasize = sizeof(data);
writeblockrequest(hgc, "setumask2"); writeblockrequest(hgc, "setumask2");
} }
/*! /*!
* Open connection to per-user cmdserver * Open connection to per-user cmdserver
* *
* If no background server running, returns NULL. * If no background server running, returns NULL.
*/ */
hgclient_t *hgc_open(const char *sockname) hgclient_t *hgc_open(const char *sockname)
{ {
int fd = socket(AF_UNIX, SOCK_STREAM, 0); int fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd < 0) if (fd < 0) {
abortmsgerrno("cannot create socket"); abortmsgerrno("cannot create socket");
}
/* don't keep fd on fork(), so that it can be closed when the parent /* don't keep fd on fork(), so that it can be closed when the parent
* process get terminated. */ * process get terminated. */
fsetcloexec(fd); fsetcloexec(fd);
struct sockaddr_un addr; struct sockaddr_un addr;
addr.sun_family = AF_UNIX; addr.sun_family = AF_UNIX;
/* use chdir to workaround small sizeof(sun_path) */ /* use chdir to workaround small sizeof(sun_path) */
int bakfd = -1; int bakfd = -1;
const char *basename = sockname; const char *basename = sockname;
{ {
const char *split = strrchr(sockname, '/'); const char *split = strrchr(sockname, '/');
if (split && split != sockname) { if (split && split != sockname) {
if (split[1] == '\0') if (split[1] == '\0') {
abortmsg("sockname cannot end with a slash"); abortmsg("sockname cannot end with a slash");
}
size_t len = split - sockname; size_t len = split - sockname;
char sockdir[len + 1]; char sockdir[len + 1];
memcpy(sockdir, sockname, len); memcpy(sockdir, sockname, len);
sockdir[len] = '\0'; sockdir[len] = '\0';
bakfd = open(".", O_DIRECTORY); bakfd = open(".", O_DIRECTORY);
if (bakfd == -1) if (bakfd == -1) {
abortmsgerrno("cannot open cwd"); abortmsgerrno("cannot open cwd");
}
int r = chdir(sockdir); int r = chdir(sockdir);
if (r != 0) if (r != 0) {
abortmsgerrno("cannot chdir %s", sockdir); abortmsgerrno("cannot chdir %s", sockdir);
}
basename = split + 1; basename = split + 1;
} }
} }
if (strlen(basename) >= sizeof(addr.sun_path)) if (strlen(basename) >= sizeof(addr.sun_path)) {
abortmsg("sockname is too long: %s", basename); abortmsg("sockname is too long: %s", basename);
}
strncpy(addr.sun_path, basename, sizeof(addr.sun_path)); strncpy(addr.sun_path, basename, sizeof(addr.sun_path));
addr.sun_path[sizeof(addr.sun_path) - 1] = '\0'; addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';
/* real connect */ /* real connect */
int r = connect(fd, (struct sockaddr *)&addr, sizeof(addr)); int r = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
if (r < 0) { if (r < 0) {
if (errno != ENOENT && errno != ECONNREFUSED) if (errno != ENOENT && errno != ECONNREFUSED) {
abortmsgerrno("cannot connect to %s", sockname); abortmsgerrno("cannot connect to %s", sockname);
} }
}
if (bakfd != -1) { if (bakfd != -1) {
fchdirx(bakfd); fchdirx(bakfd);
close(bakfd); close(bakfd);
} }
if (r < 0) { if (r < 0) {
close(fd); close(fd);
return NULL; return NULL;
} }
debugmsg("connected to %s", addr.sun_path); debugmsg("connected to %s", addr.sun_path);
hgclient_t *hgc = mallocx(sizeof(hgclient_t)); hgclient_t *hgc = mallocx(sizeof(hgclient_t));
memset(hgc, 0, sizeof(*hgc)); memset(hgc, 0, sizeof(*hgc));
hgc->sockfd = fd; hgc->sockfd = fd;
initcontext(&hgc->ctx); initcontext(&hgc->ctx);
readhello(hgc); readhello(hgc);
if (!(hgc->capflags & CAP_RUNCOMMAND)) if (!(hgc->capflags & CAP_RUNCOMMAND)) {
abortmsg("insufficient capability: runcommand"); abortmsg("insufficient capability: runcommand");
if (hgc->capflags & CAP_SETPROCNAME) }
if (hgc->capflags & CAP_SETPROCNAME) {
updateprocname(hgc); updateprocname(hgc);
if (hgc->capflags & CAP_ATTACHIO) }
if (hgc->capflags & CAP_ATTACHIO) {
attachio(hgc); attachio(hgc);
if (hgc->capflags & CAP_CHDIR) }
if (hgc->capflags & CAP_CHDIR) {
chdirtocwd(hgc); chdirtocwd(hgc);
if (hgc->capflags & CAP_SETUMASK2) }
if (hgc->capflags & CAP_SETUMASK2) {
forwardumask(hgc); forwardumask(hgc);
}
return hgc; return hgc;
} }
/*! /*!
* Close connection and free allocated memory * Close connection and free allocated memory
*/ */
void hgc_close(hgclient_t *hgc) void hgc_close(hgclient_t *hgc)
* chgserver.py for possible instruction formats. * chgserver.py for possible instruction formats.
* the list should be freed by the caller. * the list should be freed by the caller.
* the last string is guaranteed to be NULL. * the last string is guaranteed to be NULL.
*/ */
const char **hgc_validate(hgclient_t *hgc, const char *const args[], const char **hgc_validate(hgclient_t *hgc, const char *const args[],
size_t argsize) size_t argsize)
{ {
assert(hgc); assert(hgc);
if (!(hgc->capflags & CAP_VALIDATE)) if (!(hgc->capflags & CAP_VALIDATE)) {
return NULL; return NULL;
}
packcmdargs(&hgc->ctx, args, argsize); packcmdargs(&hgc->ctx, args, argsize);
writeblockrequest(hgc, "validate"); writeblockrequest(hgc, "validate");
handleresponse(hgc); handleresponse(hgc);
/* the server returns '\0' if it can handle our request */ /* the server returns '\0' if it can handle our request */
if (hgc->ctx.datasize <= 1) if (hgc->ctx.datasize <= 1) {
return NULL; return NULL;
}
/* make sure the buffer is '\0' terminated */ /* make sure the buffer is '\0' terminated */
enlargecontext(&hgc->ctx, hgc->ctx.datasize + 1); enlargecontext(&hgc->ctx, hgc->ctx.datasize + 1);
hgc->ctx.data[hgc->ctx.datasize] = '\0'; hgc->ctx.data[hgc->ctx.datasize] = '\0';
return unpackcmdargsnul(&hgc->ctx); return unpackcmdargsnul(&hgc->ctx);
} }
/*! /*!
} }
/*! /*!
* (Re-)send client's stdio channels so that the server can access to tty * (Re-)send client's stdio channels so that the server can access to tty
*/ */
void hgc_attachio(hgclient_t *hgc) void hgc_attachio(hgclient_t *hgc)
{ {
assert(hgc); assert(hgc);
if (!(hgc->capflags & CAP_ATTACHIO)) if (!(hgc->capflags & CAP_ATTACHIO)) {
return; return;
}
attachio(hgc); attachio(hgc);
} }
/*! /*!
* Update server's environment variables * Update server's environment variables
* *
* @param envp list of environment variables in "NAME=VALUE" format, * @param envp list of environment variables in "NAME=VALUE" format,
* terminated by NULL. * terminated by NULL.
*/ */
void hgc_setenv(hgclient_t *hgc, const char *const envp[]) void hgc_setenv(hgclient_t *hgc, const char *const envp[])
{ {
assert(hgc && envp); assert(hgc && envp);
if (!(hgc->capflags & CAP_SETENV)) if (!(hgc->capflags & CAP_SETENV)) {
return; return;
}
packcmdargs(&hgc->ctx, envp, /*argsize*/ -1); packcmdargs(&hgc->ctx, envp, /*argsize*/ -1);
writeblockrequest(hgc, "setenv"); writeblockrequest(hgc, "setenv");
} }

contrib/chg/procutil.c

static pid_t pagerpid = 0; static pid_t pagerpid = 0;
static pid_t peerpgid = 0; static pid_t peerpgid = 0;
static pid_t peerpid = 0; static pid_t peerpid = 0;
static void forwardsignal(int sig) static void forwardsignal(int sig)
{ {
assert(peerpid > 0); assert(peerpid > 0);
if (kill(peerpid, sig) < 0) if (kill(peerpid, sig) < 0) {
abortmsgerrno("cannot kill %d", peerpid); abortmsgerrno("cannot kill %d", peerpid);
}
debugmsg("forward signal %d", sig); debugmsg("forward signal %d", sig);
} }
static void forwardsignaltogroup(int sig) static void forwardsignaltogroup(int sig)
{ {
/* prefer kill(-pgid, sig), fallback to pid if pgid is invalid */ /* prefer kill(-pgid, sig), fallback to pid if pgid is invalid */
pid_t killpid = peerpgid > 1 ? -peerpgid : peerpid; pid_t killpid = peerpgid > 1 ? -peerpgid : peerpid;
if (kill(killpid, sig) < 0) if (kill(killpid, sig) < 0) {
abortmsgerrno("cannot kill %d", killpid); abortmsgerrno("cannot kill %d", killpid);
}
debugmsg("forward signal %d to %d", sig, killpid); debugmsg("forward signal %d to %d", sig, killpid);
} }
static void handlestopsignal(int sig) static void handlestopsignal(int sig)
{ {
sigset_t unblockset, oldset; sigset_t unblockset, oldset;
struct sigaction sa, oldsa; struct sigaction sa, oldsa;
if (sigemptyset(&unblockset) < 0) if (sigemptyset(&unblockset) < 0) {
goto error; goto error;
if (sigaddset(&unblockset, sig) < 0) }
if (sigaddset(&unblockset, sig) < 0) {
goto error; goto error;
}
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL; sa.sa_handler = SIG_DFL;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigemptyset(&sa.sa_mask) < 0) if (sigemptyset(&sa.sa_mask) < 0) {
goto error; goto error;
}
forwardsignal(sig); forwardsignal(sig);
if (raise(sig) < 0) /* resend to self */ if (raise(sig) < 0) { /* resend to self */
goto error; goto error;
if (sigaction(sig, &sa, &oldsa) < 0) }
if (sigaction(sig, &sa, &oldsa) < 0) {
goto error; goto error;
if (sigprocmask(SIG_UNBLOCK, &unblockset, &oldset) < 0) }
if (sigprocmask(SIG_UNBLOCK, &unblockset, &oldset) < 0) {
goto error; goto error;
}
/* resent signal will be handled before sigprocmask() returns */ /* resent signal will be handled before sigprocmask() returns */
if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0) if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0) {
goto error; goto error;
if (sigaction(sig, &oldsa, NULL) < 0) }
if (sigaction(sig, &oldsa, NULL) < 0) {
goto error; goto error;
}
return; return;
error: error:
abortmsgerrno("failed to handle stop signal"); abortmsgerrno("failed to handle stop signal");
} }
static void handlechildsignal(int sig UNUSED_) static void handlechildsignal(int sig UNUSED_)
{ {
if (peerpid == 0 || pagerpid == 0) if (peerpid == 0 || pagerpid == 0) {
return; return;
}
/* if pager exits, notify the server with SIGPIPE immediately. /* if pager exits, notify the server with SIGPIPE immediately.
* otherwise the server won't get SIGPIPE if it does not write * otherwise the server won't get SIGPIPE if it does not write
* anything. (issue5278) */ * anything. (issue5278) */
if (waitpid(pagerpid, NULL, WNOHANG) == pagerpid) if (waitpid(pagerpid, NULL, WNOHANG) == pagerpid) {
kill(peerpid, SIGPIPE); kill(peerpid, SIGPIPE);
} }
}
void setupsignalhandler(pid_t pid, pid_t pgid) void setupsignalhandler(pid_t pid, pid_t pgid)
{ {
if (pid <= 0) if (pid <= 0) {
return; return;
}
peerpid = pid; peerpid = pid;
peerpgid = (pgid <= 1 ? 0 : pgid); peerpgid = (pgid <= 1 ? 0 : pgid);
struct sigaction sa; struct sigaction sa;
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
/* deadly signals meant to be sent to a process group: /* deadly signals meant to be sent to a process group:
* - SIGHUP: usually generated by the kernel, when termination of a * - SIGHUP: usually generated by the kernel, when termination of a
* process causes that process group to become orphaned * process causes that process group to become orphaned
* - SIGINT: usually generated by the terminal */ * - SIGINT: usually generated by the terminal */
sa.sa_handler = forwardsignaltogroup; sa.sa_handler = forwardsignaltogroup;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigemptyset(&sa.sa_mask) < 0) if (sigemptyset(&sa.sa_mask) < 0) {
goto error; goto error;
if (sigaction(SIGHUP, &sa, NULL) < 0) }
if (sigaction(SIGHUP, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGINT, &sa, NULL) < 0) }
if (sigaction(SIGINT, &sa, NULL) < 0) {
goto error; goto error;
}
/* terminate frontend by double SIGTERM in case of server freeze */ /* terminate frontend by double SIGTERM in case of server freeze */
sa.sa_handler = forwardsignal; sa.sa_handler = forwardsignal;
sa.sa_flags |= SA_RESETHAND; sa.sa_flags |= SA_RESETHAND;
if (sigaction(SIGTERM, &sa, NULL) < 0) if (sigaction(SIGTERM, &sa, NULL) < 0) {
goto error; goto error;
}
/* notify the worker about window resize events */ /* notify the worker about window resize events */
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGWINCH, &sa, NULL) < 0) if (sigaction(SIGWINCH, &sa, NULL) < 0) {
goto error; goto error;
}
/* forward user-defined signals */ /* forward user-defined signals */
if (sigaction(SIGUSR1, &sa, NULL) < 0) if (sigaction(SIGUSR1, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGUSR2, &sa, NULL) < 0) }
if (sigaction(SIGUSR2, &sa, NULL) < 0) {
goto error; goto error;
}
/* propagate job control requests to worker */ /* propagate job control requests to worker */
sa.sa_handler = forwardsignal; sa.sa_handler = forwardsignal;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGCONT, &sa, NULL) < 0) if (sigaction(SIGCONT, &sa, NULL) < 0) {
goto error; goto error;
}
sa.sa_handler = handlestopsignal; sa.sa_handler = handlestopsignal;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGTSTP, &sa, NULL) < 0) if (sigaction(SIGTSTP, &sa, NULL) < 0) {
goto error; goto error;
}
/* get notified when pager exits */ /* get notified when pager exits */
sa.sa_handler = handlechildsignal; sa.sa_handler = handlechildsignal;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) < 0) if (sigaction(SIGCHLD, &sa, NULL) < 0) {
goto error; goto error;
}
return; return;
error: error:
abortmsgerrno("failed to set up signal handlers"); abortmsgerrno("failed to set up signal handlers");
} }
void restoresignalhandler(void) void restoresignalhandler(void)
{ {
struct sigaction sa; struct sigaction sa;
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL; sa.sa_handler = SIG_DFL;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigemptyset(&sa.sa_mask) < 0) if (sigemptyset(&sa.sa_mask) < 0) {
goto error; goto error;
}
if (sigaction(SIGHUP, &sa, NULL) < 0) if (sigaction(SIGHUP, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGTERM, &sa, NULL) < 0) }
if (sigaction(SIGTERM, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGWINCH, &sa, NULL) < 0) }
if (sigaction(SIGWINCH, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGCONT, &sa, NULL) < 0) }
if (sigaction(SIGCONT, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGTSTP, &sa, NULL) < 0) }
if (sigaction(SIGTSTP, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGCHLD, &sa, NULL) < 0) }
if (sigaction(SIGCHLD, &sa, NULL) < 0) {
goto error; goto error;
}
/* ignore Ctrl+C while shutting down to make pager exits cleanly */ /* ignore Ctrl+C while shutting down to make pager exits cleanly */
sa.sa_handler = SIG_IGN; sa.sa_handler = SIG_IGN;
if (sigaction(SIGINT, &sa, NULL) < 0) if (sigaction(SIGINT, &sa, NULL) < 0) {
goto error; goto error;
}
peerpid = 0; peerpid = 0;
return; return;
error: error:
abortmsgerrno("failed to restore signal handlers"); abortmsgerrno("failed to restore signal handlers");
} }
/* This implementation is based on hgext/pager.py (post 369741ef7253) /* This implementation is based on hgext/pager.py (post 369741ef7253)
* Return 0 if pager is not started, or pid of the pager */ * Return 0 if pager is not started, or pid of the pager */
pid_t setuppager(const char *pagercmd, const char *envp[]) pid_t setuppager(const char *pagercmd, const char *envp[])
{ {
assert(pagerpid == 0); assert(pagerpid == 0);
if (!pagercmd) if (!pagercmd) {
return 0; return 0;
}
int pipefds[2]; int pipefds[2];
if (pipe(pipefds) < 0) if (pipe(pipefds) < 0) {
return 0; return 0;
}
pid_t pid = fork(); pid_t pid = fork();
if (pid < 0) if (pid < 0) {
goto error; goto error;
}
if (pid > 0) { if (pid > 0) {
close(pipefds[0]); close(pipefds[0]);
if (dup2(pipefds[1], fileno(stdout)) < 0) if (dup2(pipefds[1], fileno(stdout)) < 0) {
goto error; goto error;
}
if (isatty(fileno(stderr))) { if (isatty(fileno(stderr))) {
if (dup2(pipefds[1], fileno(stderr)) < 0) if (dup2(pipefds[1], fileno(stderr)) < 0) {
goto error; goto error;
} }
}
close(pipefds[1]); close(pipefds[1]);
pagerpid = pid; pagerpid = pid;
return pid; return pid;
} else { } else {
dup2(pipefds[0], fileno(stdin)); dup2(pipefds[0], fileno(stdin));
close(pipefds[0]); close(pipefds[0]);
close(pipefds[1]); close(pipefds[1]);
close(pipefds[0]); close(pipefds[0]);
close(pipefds[1]); close(pipefds[1]);
abortmsgerrno("failed to prepare pager"); abortmsgerrno("failed to prepare pager");
return 0; return 0;
} }
void waitpager(void) void waitpager(void)
{ {
if (pagerpid == 0) if (pagerpid == 0) {
return; return;
}
/* close output streams to notify the pager its input ends */ /* close output streams to notify the pager its input ends */
fclose(stdout); fclose(stdout);
fclose(stderr); fclose(stderr);
while (1) { while (1) {
pid_t ret = waitpid(pagerpid, NULL, 0); pid_t ret = waitpid(pagerpid, NULL, 0);
if (ret == -1 && errno == EINTR) if (ret == -1 && errno == EINTR) {
continue; continue;
}
break; break;
} }
} }

contrib/chg/util.c

#include <unistd.h> #include <unistd.h>
#include "util.h" #include "util.h"
static int colorenabled = 0; static int colorenabled = 0;
static inline void fsetcolor(FILE *fp, const char *code) static inline void fsetcolor(FILE *fp, const char *code)
{ {
if (!colorenabled) if (!colorenabled) {
return; return;
}
fprintf(fp, "\033[%sm", code); fprintf(fp, "\033[%sm", code);
} }
static void vabortmsgerrno(int no, const char *fmt, va_list args) static void vabortmsgerrno(int no, const char *fmt, va_list args)
{ {
fsetcolor(stderr, "1;31"); fsetcolor(stderr, "1;31");
fputs("chg: abort: ", stderr); fputs("chg: abort: ", stderr);
vfprintf(stderr, fmt, args); vfprintf(stderr, fmt, args);
if (no != 0) if (no != 0) {
fprintf(stderr, " (errno = %d, %s)", no, strerror(no)); fprintf(stderr, " (errno = %d, %s)", no, strerror(no));
}
fsetcolor(stderr, ""); fsetcolor(stderr, "");
fputc('\n', stderr); fputc('\n', stderr);
exit(255); exit(255);
} }
void abortmsg(const char *fmt, ...) void abortmsg(const char *fmt, ...)
{ {
va_list args; va_list args;
void enabledebugmsg(void) void enabledebugmsg(void)
{ {
debugmsgenabled = 1; debugmsgenabled = 1;
debugstart = now(); debugstart = now();
} }
void debugmsg(const char *fmt, ...) void debugmsg(const char *fmt, ...)
{ {
if (!debugmsgenabled) if (!debugmsgenabled) {
return; return;
}
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
fsetcolor(stderr, "1;30"); fsetcolor(stderr, "1;30");
fprintf(stderr, "chg: debug: %4.6f ", now() - debugstart); fprintf(stderr, "chg: debug: %4.6f ", now() - debugstart);
vfprintf(stderr, fmt, args); vfprintf(stderr, fmt, args);
fsetcolor(stderr, ""); fsetcolor(stderr, "");
fputc('\n', stderr); fputc('\n', stderr);
va_end(args); va_end(args);
} }
void fchdirx(int dirfd) void fchdirx(int dirfd)
{ {
int r = fchdir(dirfd); int r = fchdir(dirfd);
if (r == -1) if (r == -1) {
abortmsgerrno("failed to fchdir"); abortmsgerrno("failed to fchdir");
} }
}
void fsetcloexec(int fd) void fsetcloexec(int fd)
{ {
int flags = fcntl(fd, F_GETFD); int flags = fcntl(fd, F_GETFD);
if (flags < 0) if (flags < 0) {
abortmsgerrno("cannot get flags of fd %d", fd); abortmsgerrno("cannot get flags of fd %d", fd);
if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0) }
if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0) {
abortmsgerrno("cannot set flags of fd %d", fd); abortmsgerrno("cannot set flags of fd %d", fd);
} }
}
void *mallocx(size_t size) void *mallocx(size_t size)
{ {
void *result = malloc(size); void *result = malloc(size);
if (!result) if (!result) {
abortmsg("failed to malloc"); abortmsg("failed to malloc");
}
return result; return result;
} }
void *reallocx(void *ptr, size_t size) void *reallocx(void *ptr, size_t size)
{ {
void *result = realloc(ptr, size); void *result = realloc(ptr, size);
if (!result) if (!result) {
abortmsg("failed to realloc"); abortmsg("failed to realloc");
}
return result; return result;
} }
/* /*
* Execute a shell command in mostly the same manner as system(), with the * Execute a shell command in mostly the same manner as system(), with the
* give environment variables, after chdir to the given cwd. Returns a status * give environment variables, after chdir to the given cwd. Returns a status
* code compatible with the Python subprocess module. * code compatible with the Python subprocess module.
*/ */
int runshellcmd(const char *cmd, const char *envp[], const char *cwd) int runshellcmd(const char *cmd, const char *envp[], const char *cwd)
{ {
enum { F_SIGINT = 1, F_SIGQUIT = 2, F_SIGMASK = 4, F_WAITPID = 8 }; enum { F_SIGINT = 1, F_SIGQUIT = 2, F_SIGMASK = 4, F_WAITPID = 8 };
unsigned int doneflags = 0; unsigned int doneflags = 0;
int status = 0; int status = 0;
struct sigaction newsa, oldsaint, oldsaquit; struct sigaction newsa, oldsaint, oldsaquit;
sigset_t oldmask; sigset_t oldmask;
/* block or mask signals just as system() does */ /* block or mask signals just as system() does */
memset(&newsa, 0, sizeof(newsa)); memset(&newsa, 0, sizeof(newsa));
newsa.sa_handler = SIG_IGN; newsa.sa_handler = SIG_IGN;
newsa.sa_flags = 0; newsa.sa_flags = 0;
if (sigemptyset(&newsa.sa_mask) < 0) if (sigemptyset(&newsa.sa_mask) < 0) {
goto done; goto done;
if (sigaction(SIGINT, &newsa, &oldsaint) < 0) }
if (sigaction(SIGINT, &newsa, &oldsaint) < 0) {
goto done; goto done;
}
doneflags |= F_SIGINT; doneflags |= F_SIGINT;
if (sigaction(SIGQUIT, &newsa, &oldsaquit) < 0) if (sigaction(SIGQUIT, &newsa, &oldsaquit) < 0) {
goto done; goto done;
}
doneflags |= F_SIGQUIT; doneflags |= F_SIGQUIT;
if (sigaddset(&newsa.sa_mask, SIGCHLD) < 0) if (sigaddset(&newsa.sa_mask, SIGCHLD) < 0) {
goto done; goto done;
if (sigprocmask(SIG_BLOCK, &newsa.sa_mask, &oldmask) < 0) }
if (sigprocmask(SIG_BLOCK, &newsa.sa_mask, &oldmask) < 0) {
goto done; goto done;
}
doneflags |= F_SIGMASK; doneflags |= F_SIGMASK;
pid_t pid = fork(); pid_t pid = fork();
if (pid < 0) if (pid < 0) {
goto done; goto done;
}
if (pid == 0) { if (pid == 0) {
sigaction(SIGINT, &oldsaint, NULL); sigaction(SIGINT, &oldsaint, NULL);
sigaction(SIGQUIT, &oldsaquit, NULL); sigaction(SIGQUIT, &oldsaquit, NULL);
sigprocmask(SIG_SETMASK, &oldmask, NULL); sigprocmask(SIG_SETMASK, &oldmask, NULL);
if (cwd && chdir(cwd) < 0) if (cwd && chdir(cwd) < 0) {
_exit(127); _exit(127);
}
const char *argv[] = {"sh", "-c", cmd, NULL}; const char *argv[] = {"sh", "-c", cmd, NULL};
if (envp) { if (envp) {
execve("/bin/sh", (char **)argv, (char **)envp); execve("/bin/sh", (char **)argv, (char **)envp);
} else { } else {
execv("/bin/sh", (char **)argv); execv("/bin/sh", (char **)argv);
} }
_exit(127); _exit(127);
} else { } else {
if (waitpid(pid, &status, 0) < 0) if (waitpid(pid, &status, 0) < 0) {
goto done; goto done;
}
doneflags |= F_WAITPID; doneflags |= F_WAITPID;
} }
done: done:
if (doneflags & F_SIGINT) if (doneflags & F_SIGINT) {
sigaction(SIGINT, &oldsaint, NULL); sigaction(SIGINT, &oldsaint, NULL);
if (doneflags & F_SIGQUIT) }
if (doneflags & F_SIGQUIT) {
sigaction(SIGQUIT, &oldsaquit, NULL); sigaction(SIGQUIT, &oldsaquit, NULL);
if (doneflags & F_SIGMASK) }
if (doneflags & F_SIGMASK) {
sigprocmask(SIG_SETMASK, &oldmask, NULL); sigprocmask(SIG_SETMASK, &oldmask, NULL);
}
/* no way to report other errors, use 127 (= shell termination) */ /* no way to report other errors, use 127 (= shell termination) */
if (!(doneflags & F_WAITPID)) if (!(doneflags & F_WAITPID)) {
return 127; return 127;
if (WIFEXITED(status)) }
if (WIFEXITED(status)) {
return WEXITSTATUS(status); return WEXITSTATUS(status);
if (WIFSIGNALED(status)) }
if (WIFSIGNALED(status)) {
return -WTERMSIG(status); return -WTERMSIG(status);
}
return 127; return 127;
} }

mercurial/bdiff.c

unsigned hash; unsigned hash;
int i; int i;
const char *p, *b = a; const char *p, *b = a;
const char *const plast = a + len - 1; const char *const plast = a + len - 1;
struct bdiff_line *l; struct bdiff_line *l;
/* count the lines */ /* count the lines */
i = 1; /* extra line for sentinel */ i = 1; /* extra line for sentinel */
for (p = a; p < plast; p++) for (p = a; p < plast; p++) {
if (*p == '\n') if (*p == '\n') {
i++; i++;
if (p == plast) }
}
if (p == plast) {
i++; i++;
}
*lr = l = (struct bdiff_line *)calloc(i, sizeof(struct bdiff_line)); *lr = l = (struct bdiff_line *)calloc(i, sizeof(struct bdiff_line));
if (!l) if (!l) {
return -1; return -1;
}
/* build the line array and calculate hashes */ /* build the line array and calculate hashes */
hash = 0; hash = 0;
for (p = a; p < plast; p++) { for (p = a; p < plast; p++) {
hash = HASH(hash, *p); hash = HASH(hash, *p);
if (*p == '\n') { if (*p == '\n') {
l->hash = hash; l->hash = hash;
static int equatelines(struct bdiff_line *a, int an, struct bdiff_line *b, static int equatelines(struct bdiff_line *a, int an, struct bdiff_line *b,
int bn) int bn)
{ {
int i, j, buckets = 1, t, scale; int i, j, buckets = 1, t, scale;
struct pos *h = NULL; struct pos *h = NULL;
/* build a hash table of the next highest power of 2 */ /* build a hash table of the next highest power of 2 */
while (buckets < bn + 1) while (buckets < bn + 1) {
buckets *= 2; buckets *= 2;
}
/* try to allocate a large hash table to avoid collisions */ /* try to allocate a large hash table to avoid collisions */
for (scale = 4; scale; scale /= 2) { for (scale = 4; scale; scale /= 2) {
h = (struct pos *)calloc(buckets, scale * sizeof(struct pos)); h = (struct pos *)calloc(buckets, scale * sizeof(struct pos));
if (h) if (h) {
break; break;
} }
}
if (!h) if (!h) {
return 0; return 0;
}
buckets = buckets * scale - 1; buckets = buckets * scale - 1;
/* clear the hash table */ /* clear the hash table */
for (i = 0; i <= buckets; i++) { for (i = 0; i <= buckets; i++) {
h[i].pos = -1; h[i].pos = -1;
h[i].len = 0; h[i].len = 0;
} }
/* add lines to the hash table chains */ /* add lines to the hash table chains */
for (i = 0; i < bn; i++) { for (i = 0; i < bn; i++) {
/* find the equivalence class */ /* find the equivalence class */
for (j = b[i].hash & buckets; h[j].pos != -1; for (j = b[i].hash & buckets; h[j].pos != -1;
j = (j + 1) & buckets) j = (j + 1) & buckets) {
if (!cmp(b + i, b + h[j].pos)) if (!cmp(b + i, b + h[j].pos)) {
break; break;
}
}
/* add to the head of the equivalence class */ /* add to the head of the equivalence class */
b[i].n = h[j].pos; b[i].n = h[j].pos;
b[i].e = j; b[i].e = j;
h[j].pos = i; h[j].pos = i;
h[j].len++; /* keep track of popularity */ h[j].len++; /* keep track of popularity */
} }
/* compute popularity threshold */ /* compute popularity threshold */
t = (bn >= 31000) ? bn / 1000 : 1000000 / (bn + 1); t = (bn >= 31000) ? bn / 1000 : 1000000 / (bn + 1);
/* match items in a to their equivalence class in b */ /* match items in a to their equivalence class in b */
for (i = 0; i < an; i++) { for (i = 0; i < an; i++) {
/* find the equivalence class */ /* find the equivalence class */
for (j = a[i].hash & buckets; h[j].pos != -1; for (j = a[i].hash & buckets; h[j].pos != -1;
j = (j + 1) & buckets) j = (j + 1) & buckets) {
if (!cmp(a + i, b + h[j].pos)) if (!cmp(a + i, b + h[j].pos)) {
break; break;
}
}
a[i].e = j; /* use equivalence class for quick compare */ a[i].e = j; /* use equivalence class for quick compare */
if (h[j].len <= t) if (h[j].len <= t) {
a[i].n = h[j].pos; /* point to head of match list */ a[i].n = h[j].pos; /* point to head of match list */
else } else {
a[i].n = -1; /* too popular */ a[i].n = -1; /* too popular */
} }
}
/* discard hash tables */ /* discard hash tables */
free(h); free(h);
return 1; return 1;
} }
static int longest_match(struct bdiff_line *a, struct bdiff_line *b, static int longest_match(struct bdiff_line *a, struct bdiff_line *b,
struct pos *pos, int a1, int a2, int b1, int b2, struct pos *pos, int a1, int a2, int b1, int b2,
int *omi, int *omj) int *omi, int *omj)
{ {
int mi = a1, mj = b1, mk = 0, i, j, k, half, bhalf; int mi = a1, mj = b1, mk = 0, i, j, k, half, bhalf;
/* window our search on large regions to better bound /* window our search on large regions to better bound
worst-case performance. by choosing a window at the end, we worst-case performance. by choosing a window at the end, we
reduce skipping overhead on the b chains. */ reduce skipping overhead on the b chains. */
if (a2 - a1 > 30000) if (a2 - a1 > 30000) {
a1 = a2 - 30000; a1 = a2 - 30000;
}
half = (a1 + a2 - 1) / 2; half = (a1 + a2 - 1) / 2;
bhalf = (b1 + b2 - 1) / 2; bhalf = (b1 + b2 - 1) / 2;
for (i = a1; i < a2; i++) { for (i = a1; i < a2; i++) {
/* skip all lines in b after the current block */ /* skip all lines in b after the current block */
for (j = a[i].n; j >= b2; j = b[j].n) for (j = a[i].n; j >= b2; j = b[j].n) {
; ;
}
/* loop through all lines match a[i] in b */ /* loop through all lines match a[i] in b */
for (; j >= b1; j = b[j].n) { for (; j >= b1; j = b[j].n) {
/* does this extend an earlier match? */ /* does this extend an earlier match? */
for (k = 1; j - k >= b1 && i - k >= a1; k++) { for (k = 1; j - k >= b1 && i - k >= a1; k++) {
/* reached an earlier match? */ /* reached an earlier match? */
if (pos[j - k].pos == i - k) { if (pos[j - k].pos == i - k) {
k += pos[j - k].len; k += pos[j - k].len;
break; break;
} }
/* previous line mismatch? */ /* previous line mismatch? */
if (a[i - k].e != b[j - k].e) if (a[i - k].e != b[j - k].e) {
break; break;
} }
}
pos[j].pos = i; pos[j].pos = i;
pos[j].len = k; pos[j].len = k;
/* best match so far? we prefer matches closer /* best match so far? we prefer matches closer
to the middle to balance recursion */ to the middle to balance recursion */
if (k > mk) { if (k > mk) {
/* a longer match */ /* a longer match */
} }
if (mk) { if (mk) {
mi = mi - mk + 1; mi = mi - mk + 1;
mj = mj - mk + 1; mj = mj - mk + 1;
} }
/* expand match to include subsequent popular lines */ /* expand match to include subsequent popular lines */
while (mi + mk < a2 && mj + mk < b2 && a[mi + mk].e == b[mj + mk].e) while (mi + mk < a2 && mj + mk < b2 && a[mi + mk].e == b[mj + mk].e) {
mk++; mk++;
}
*omi = mi; *omi = mi;
*omj = mj; *omj = mj;
return mk; return mk;
} }
static struct bdiff_hunk *recurse(struct bdiff_line *a, struct bdiff_line *b, static struct bdiff_hunk *recurse(struct bdiff_line *a, struct bdiff_line *b,
struct pos *pos, int a1, int a2, int b1, struct pos *pos, int a1, int a2, int b1,
int b2, struct bdiff_hunk *l) int b2, struct bdiff_hunk *l)
{ {
int i, j, k; int i, j, k;
while (1) { while (1) {
/* find the longest match in this chunk */ /* find the longest match in this chunk */
k = longest_match(a, b, pos, a1, a2, b1, b2, &i, &j); k = longest_match(a, b, pos, a1, a2, b1, b2, &i, &j);
if (!k) if (!k) {
return l; return l;
}
/* and recurse on the remaining chunks on either side */ /* and recurse on the remaining chunks on either side */
l = recurse(a, b, pos, a1, i, b1, j, l); l = recurse(a, b, pos, a1, i, b1, j, l);
if (!l) if (!l) {
return NULL; return NULL;
}
l->next = l->next =
(struct bdiff_hunk *)malloc(sizeof(struct bdiff_hunk)); (struct bdiff_hunk *)malloc(sizeof(struct bdiff_hunk));
if (!l->next) if (!l->next) {
return NULL; return NULL;
}
l = l->next; l = l->next;
l->a1 = i; l->a1 = i;
l->a2 = i + k; l->a2 = i + k;
l->b1 = j; l->b1 = j;
l->b2 = j + k; l->b2 = j + k;
l->next = NULL; l->next = NULL;
/* allocate and fill arrays */ /* allocate and fill arrays */
t = equatelines(a, an, b, bn); t = equatelines(a, an, b, bn);
pos = (struct pos *)calloc(bn ? bn : 1, sizeof(struct pos)); pos = (struct pos *)calloc(bn ? bn : 1, sizeof(struct pos));
if (pos && t) { if (pos && t) {
/* generate the matching block list */ /* generate the matching block list */
curr = recurse(a, b, pos, 0, an, 0, bn, base); curr = recurse(a, b, pos, 0, an, 0, bn, base);
if (!curr) if (!curr) {
return -1; return -1;
}
/* sentinel end hunk */ /* sentinel end hunk */
curr->next = curr->next =
(struct bdiff_hunk *)malloc(sizeof(struct bdiff_hunk)); (struct bdiff_hunk *)malloc(sizeof(struct bdiff_hunk));
if (!curr->next) if (!curr->next) {
return -1; return -1;
}
curr = curr->next; curr = curr->next;
curr->a1 = curr->a2 = an; curr->a1 = curr->a2 = an;
curr->b1 = curr->b2 = bn; curr->b1 = curr->b2 = bn;
curr->next = NULL; curr->next = NULL;
} }
free(pos); free(pos);
/* normalize the hunk list, try to push each hunk towards the end */ /* normalize the hunk list, try to push each hunk towards the end */
for (curr = base->next; curr; curr = curr->next) { for (curr = base->next; curr; curr = curr->next) {
struct bdiff_hunk *next = curr->next; struct bdiff_hunk *next = curr->next;
if (!next) if (!next) {
break; break;
}
if (curr->a2 == next->a1 || curr->b2 == next->b1) if (curr->a2 == next->a1 || curr->b2 == next->b1) {
while (curr->a2 < an && curr->b2 < bn && while (curr->a2 < an && curr->b2 < bn &&
next->a1 < next->a2 && next->b1 < next->b2 && next->a1 < next->a2 && next->b1 < next->b2 &&
!cmp(a + curr->a2, b + curr->b2)) { !cmp(a + curr->a2, b + curr->b2)) {
curr->a2++; curr->a2++;
next->a1++; next->a1++;
curr->b2++; curr->b2++;
next->b1++; next->b1++;
} }
} }
}
for (curr = base->next; curr; curr = curr->next) for (curr = base->next; curr; curr = curr->next) {
count++; count++;
}
return count; return count;
} }
/* deallocate list of hunks; l may be NULL */ /* deallocate list of hunks; l may be NULL */
void bdiff_freehunks(struct bdiff_hunk *l) void bdiff_freehunks(struct bdiff_hunk *l)
{ {
struct bdiff_hunk *n; struct bdiff_hunk *n;
for (; l; l = n) { for (; l; l = n) {
n = l->next; n = l->next;
free(l); free(l);
} }
} }

mercurial/cext/base85.c

"abcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~"; "abcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~";
static char b85dec[256]; static char b85dec[256];
static void b85prep(void) static void b85prep(void)
{ {
unsigned i; unsigned i;
memset(b85dec, 0, sizeof(b85dec)); memset(b85dec, 0, sizeof(b85dec));
for (i = 0; i < sizeof(b85chars); i++) for (i = 0; i < sizeof(b85chars); i++) {
b85dec[(int)(b85chars[i])] = i + 1; b85dec[(int)(b85chars[i])] = i + 1;
} }
}
static PyObject *b85encode(PyObject *self, PyObject *args) static PyObject *b85encode(PyObject *self, PyObject *args)
{ {
const unsigned char *text; const unsigned char *text;
PyObject *out; PyObject *out;
char *dst; char *dst;
Py_ssize_t len, olen, i; Py_ssize_t len, olen, i;
unsigned int acc, val, ch; unsigned int acc, val, ch;
int pad = 0; int pad = 0;
if (!PyArg_ParseTuple(args, PY23("s#|i", "y#|i"), &text, &len, &pad)) if (!PyArg_ParseTuple(args, PY23("s#|i", "y#|i"), &text, &len, &pad)) {
return NULL; return NULL;
}
if (pad) if (pad) {
olen = ((len + 3) / 4 * 5) - 3; olen = ((len + 3) / 4 * 5) - 3;
else { } else {
olen = len % 4; olen = len % 4;
if (olen) if (olen) {
olen++; olen++;
}
olen += len / 4 * 5; olen += len / 4 * 5;
} }
if (!(out = PyBytes_FromStringAndSize(NULL, olen + 3))) if (!(out = PyBytes_FromStringAndSize(NULL, olen + 3))) {
return NULL; return NULL;
}
dst = PyBytes_AsString(out); dst = PyBytes_AsString(out);
while (len) { while (len) {
acc = 0; acc = 0;
for (i = 24; i >= 0; i -= 8) { for (i = 24; i >= 0; i -= 8) {
ch = *text++; ch = *text++;
acc |= ch << i; acc |= ch << i;
if (--len == 0) if (--len == 0) {
break; break;
} }
}
for (i = 4; i >= 0; i--) { for (i = 4; i >= 0; i--) {
val = acc % 85; val = acc % 85;
acc /= 85; acc /= 85;
dst[i] = b85chars[val]; dst[i] = b85chars[val];
} }
dst += 5; dst += 5;
} }
if (!pad) if (!pad) {
_PyBytes_Resize(&out, olen); _PyBytes_Resize(&out, olen);
}
return out; return out;
} }
static PyObject *b85decode(PyObject *self, PyObject *args) static PyObject *b85decode(PyObject *self, PyObject *args)
{ {
PyObject *out = NULL; PyObject *out = NULL;
const char *text; const char *text;
char *dst; char *dst;
Py_ssize_t len, i, j, olen, cap; Py_ssize_t len, i, j, olen, cap;
int c; int c;
unsigned int acc; unsigned int acc;
if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &text, &len)) if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &text, &len)) {
return NULL; return NULL;
}
olen = len / 5 * 4; olen = len / 5 * 4;
i = len % 5; i = len % 5;
if (i) if (i) {
olen += i - 1; olen += i - 1;
if (!(out = PyBytes_FromStringAndSize(NULL, olen))) }
if (!(out = PyBytes_FromStringAndSize(NULL, olen))) {
return NULL; return NULL;
}
dst = PyBytes_AsString(out); dst = PyBytes_AsString(out);
i = 0; i = 0;
while (i < len) { while (i < len) {
acc = 0; acc = 0;
cap = len - i - 1; cap = len - i - 1;
if (cap > 4) if (cap > 4) {
cap = 4; cap = 4;
}
for (j = 0; j < cap; i++, j++) { for (j = 0; j < cap; i++, j++) {
c = b85dec[(int)*text++] - 1; c = b85dec[(int)*text++] - 1;
if (c < 0) { if (c < 0) {
PyErr_Format( PyErr_Format(
PyExc_ValueError, PyExc_ValueError,
"bad base85 character at position %d", "bad base85 character at position %d",
(int)i); (int)i);
goto bail; goto bail;
(int)i); (int)i);
goto bail; goto bail;
} }
acc += c; acc += c;
} }
cap = olen < 4 ? olen : 4; cap = olen < 4 ? olen : 4;
olen -= cap; olen -= cap;
for (j = 0; j < 4 - cap; j++) for (j = 0; j < 4 - cap; j++) {
acc *= 85; acc *= 85;
if (cap && cap < 4) }
if (cap && cap < 4) {
acc += 0xffffff >> (cap - 1) * 8; acc += 0xffffff >> (cap - 1) * 8;
}
for (j = 0; j < cap; j++) { for (j = 0; j < cap; j++) {
acc = (acc << 8) | (acc >> 24); acc = (acc << 8) | (acc >> 24);
*dst++ = acc; *dst++ = acc;
} }
} }
return out; return out;
bail: bail:

mercurial/cext/bdiff.c

{ {
PyObject *sa, *sb, *rl = NULL, *m; PyObject *sa, *sb, *rl = NULL, *m;
struct bdiff_line *a, *b; struct bdiff_line *a, *b;
struct bdiff_hunk l, *h; struct bdiff_hunk l, *h;
int an, bn, count, pos = 0; int an, bn, count, pos = 0;
l.next = NULL; l.next = NULL;
if (!PyArg_ParseTuple(args, "SS:bdiff", &sa, &sb)) if (!PyArg_ParseTuple(args, "SS:bdiff", &sa, &sb)) {
return NULL; return NULL;
}
an = bdiff_splitlines(PyBytes_AsString(sa), PyBytes_Size(sa), &a); an = bdiff_splitlines(PyBytes_AsString(sa), PyBytes_Size(sa), &a);
bn = bdiff_splitlines(PyBytes_AsString(sb), PyBytes_Size(sb), &b); bn = bdiff_splitlines(PyBytes_AsString(sb), PyBytes_Size(sb), &b);
if (!a || !b) if (!a || !b) {
goto nomem; goto nomem;
}
count = bdiff_diff(a, an, b, bn, &l); count = bdiff_diff(a, an, b, bn, &l);
if (count < 0) if (count < 0) {
goto nomem; goto nomem;
}
rl = PyList_New(count); rl = PyList_New(count);
if (!rl) if (!rl) {
goto nomem; goto nomem;
}
for (h = l.next; h; h = h->next) { for (h = l.next; h; h = h->next) {
m = Py_BuildValue("iiii", h->a1, h->a2, h->b1, h->b2); m = Py_BuildValue("iiii", h->a1, h->a2, h->b1, h->b2);
PyList_SetItem(rl, pos, m); PyList_SetItem(rl, pos, m);
pos++; pos++;
} }
nomem: nomem:
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"), &ba, &bb)) if (!PyArg_ParseTuple(args, PY23("s*s*:bdiff", "y*y*:bdiff"), &ba,
&bb)) {
return NULL; return NULL;
}
if (!PyBuffer_IsContiguous(&ba, 'C') || ba.ndim > 1) { if (!PyBuffer_IsContiguous(&ba, 'C') || ba.ndim > 1) {
PyErr_SetString(PyExc_ValueError, "bdiff input not contiguous"); PyErr_SetString(PyExc_ValueError, "bdiff input not contiguous");
goto cleanup; goto cleanup;
} }
if (!PyBuffer_IsContiguous(&bb, 'C') || bb.ndim > 1) { if (!PyBuffer_IsContiguous(&bb, 'C') || bb.ndim > 1) {
PyErr_SetString(PyExc_ValueError, "bdiff input not contiguous"); PyErr_SetString(PyExc_ValueError, "bdiff input not contiguous");
goto cleanup; goto cleanup;
} }
la = ba.len; la = ba.len;
lb = bb.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");
goto cleanup; goto cleanup;
} }
_save = PyEval_SaveThread(); _save = PyEval_SaveThread();
lmax = la > lb ? lb : la; lmax = la > lb ? lb : la;
for (ia = ba.buf, ib = bb.buf; li < lmax && *ia == *ib; for (ia = ba.buf, ib = bb.buf; li < lmax && *ia == *ib;
++li, ++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((char *)ba.buf + lcommon, la - lcommon, &al); an = bdiff_splitlines((char *)ba.buf + lcommon, la - lcommon, &al);
bn = bdiff_splitlines((char *)bb.buf + lcommon, lb - lcommon, &bl); bn = bdiff_splitlines((char *)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();
goto cleanup; goto cleanup;
} }
/* calculate length of output */ /* calculate length of output */
la = lb = 0; la = lb = 0;
for (h = l.next; h; h = h->next) { for (h = l.next; h; h = h->next) {
if (h->a1 != la || h->b1 != lb) if (h->a1 != la || h->b1 != lb) {
len += 12 + bl[h->b1].l - bl[lb].l; len += 12 + bl[h->b1].l - bl[lb].l;
}
la = h->a2; la = h->a2;
lb = h->b2; lb = h->b2;
} }
PyEval_RestoreThread(_save); PyEval_RestoreThread(_save);
_save = NULL; _save = NULL;
result = PyBytes_FromStringAndSize(NULL, len); result = PyBytes_FromStringAndSize(NULL, len);
if (!result) if (!result) {
goto cleanup; goto cleanup;
}
/* build binary patch */ /* build binary patch */
rb = PyBytes_AsString(result); rb = PyBytes_AsString(result);
la = lb = 0; la = lb = 0;
for (h = l.next; h; h = h->next) { for (h = l.next; h; h = h->next) {
if (h->a1 != la || h->b1 != lb) { if (h->a1 != la || h->b1 != lb) {
len = bl[h->b1].l - bl[lb].l; len = bl[h->b1].l - bl[lb].l;
putbe32((uint32_t)(al[la].l + lcommon - al->l), rb); putbe32((uint32_t)(al[la].l + lcommon - al->l), rb);
putbe32((uint32_t)(al[h->a1].l + lcommon - al->l), putbe32((uint32_t)(al[h->a1].l + lcommon - al->l),
rb + 4); rb + 4);
putbe32((uint32_t)len, rb + 8); putbe32((uint32_t)len, rb + 8);
memcpy(rb + 12, bl[lb].l, len); memcpy(rb + 12, bl[lb].l, len);
rb += 12 + len; rb += 12 + len;
} }
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(&ba);
PyBuffer_Release(&bb); PyBuffer_Release(&bb);
free(al); free(al);
free(bl); free(bl);
bdiff_freehunks(l.next); bdiff_freehunks(l.next);
return result; return result;
} }
/* /*
* If allws != 0, remove all whitespace (' ', \t and \r). Otherwise, * If allws != 0, remove all whitespace (' ', \t and \r). Otherwise,
* reduce whitespace sequences to a single space and trim remaining whitespace * reduce whitespace sequences to a single space and trim remaining whitespace
* from end of lines. * from end of lines.
*/ */
static PyObject *fixws(PyObject *self, PyObject *args) static PyObject *fixws(PyObject *self, PyObject *args)
{ {
PyObject *s, *result = NULL; PyObject *s, *result = NULL;
char allws, c; char allws, c;
const char *r; const char *r;
Py_ssize_t i, rlen, wlen = 0; Py_ssize_t i, rlen, wlen = 0;
char *w; char *w;
if (!PyArg_ParseTuple(args, "Sb:fixws", &s, &allws)) if (!PyArg_ParseTuple(args, "Sb:fixws", &s, &allws)) {
return NULL; return NULL;
}
r = PyBytes_AsString(s); r = PyBytes_AsString(s);
rlen = PyBytes_Size(s); rlen = PyBytes_Size(s);
w = (char *)PyMem_Malloc(rlen ? rlen : 1); w = (char *)PyMem_Malloc(rlen ? rlen : 1);
if (!w) if (!w) {
goto nomem; goto nomem;
}
for (i = 0; i != rlen; i++) { for (i = 0; i != rlen; i++) {
c = r[i]; c = r[i];
if (c == ' ' || c == '\t' || c == '\r') { if (c == ' ' || c == '\t' || c == '\r') {
if (!allws && (wlen == 0 || w[wlen - 1] != ' ')) if (!allws && (wlen == 0 || w[wlen - 1] != ' ')) {
w[wlen++] = ' '; w[wlen++] = ' ';
}
} else if (c == '\n' && !allws && wlen > 0 && } else if (c == '\n' && !allws && wlen > 0 &&
w[wlen - 1] == ' ') { w[wlen - 1] == ' ') {
w[wlen - 1] = '\n'; w[wlen - 1] = '\n';
} else { } else {
w[wlen++] = c; w[wlen++] = c;
} }
} }
result = PyBytes_FromStringAndSize(w, wlen); result = PyBytes_FromStringAndSize(w, wlen);
nomem: nomem:
PyMem_Free(w); PyMem_Free(w);
return result ? result : PyErr_NoMemory(); return result ? result : PyErr_NoMemory();
} }
static bool sliceintolist(PyObject *list, Py_ssize_t destidx, static bool sliceintolist(PyObject *list, Py_ssize_t destidx,
const char *source, Py_ssize_t len) const char *source, Py_ssize_t len)
{ {
PyObject *sliced = PyBytes_FromStringAndSize(source, len); PyObject *sliced = PyBytes_FromStringAndSize(source, len);
if (sliced == NULL) if (sliced == NULL) {
return false; return false;
}
PyList_SET_ITEM(list, destidx, sliced); PyList_SET_ITEM(list, destidx, sliced);
return true; return true;
} }
static PyObject *splitnewlines(PyObject *self, PyObject *args) static PyObject *splitnewlines(PyObject *self, PyObject *args)
{ {
const char *text; const char *text;
Py_ssize_t nelts = 0, size, i, start = 0; Py_ssize_t nelts = 0, size, i, start = 0;
PyObject *result = NULL; PyObject *result = NULL;
if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &text, &size)) { if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &text, &size)) {
goto abort; goto abort;
} }
if (!size) { if (!size) {
return PyList_New(0); return PyList_New(0);
} }
/* This loops to size-1 because if the last byte is a newline, /* This loops to size-1 because if the last byte is a newline,
* we don't want to perform a split there. */ * we don't want to perform a split there. */
for (i = 0; i < size - 1; ++i) { for (i = 0; i < size - 1; ++i) {
if (text[i] == '\n') { if (text[i] == '\n') {
++nelts; ++nelts;
} }
} }
if ((result = PyList_New(nelts + 1)) == NULL) if ((result = PyList_New(nelts + 1)) == NULL) {
goto abort; goto abort;
}
nelts = 0; nelts = 0;
for (i = 0; i < size - 1; ++i) { for (i = 0; i < size - 1; ++i) {
if (text[i] == '\n') { if (text[i] == '\n') {
if (!sliceintolist(result, nelts++, text + start, if (!sliceintolist(result, nelts++, text + start,
i - start + 1)) i - start + 1)) {
goto abort; goto abort;
}
start = i + 1; start = i + 1;
} }
} }
if (!sliceintolist(result, nelts++, text + start, size - start)) if (!sliceintolist(result, nelts++, text + start, size - start)) {
goto abort; goto abort;
}
return result; return result;
abort: abort:
Py_XDECREF(result); Py_XDECREF(result);
return NULL; return NULL;
} }
static int hunk_consumer(int64_t a1, int64_t a2, int64_t b1, int64_t b2, static int hunk_consumer(int64_t a1, int64_t a2, int64_t b1, int64_t b2,
void *priv) void *priv)
{ {
PyObject *rl = (PyObject *)priv; PyObject *rl = (PyObject *)priv;
PyObject *m = Py_BuildValue("LLLL", a1, a2, b1, b2); PyObject *m = Py_BuildValue("LLLL", a1, a2, b1, b2);
int r; int r;
if (!m) if (!m) {
return -1; return -1;
}
r = PyList_Append(rl, m); r = PyList_Append(rl, m);
Py_DECREF(m); Py_DECREF(m);
return r; return r;
} }
static PyObject *xdiffblocks(PyObject *self, PyObject *args) static PyObject *xdiffblocks(PyObject *self, PyObject *args)
{ {
Py_ssize_t la, lb; Py_ssize_t la, lb;
mmfile_t a, b; mmfile_t a, b;
PyObject *rl; PyObject *rl;
xpparam_t xpp = { xpparam_t xpp = {
XDF_INDENT_HEURISTIC, /* flags */ XDF_INDENT_HEURISTIC, /* flags */
}; };
xdemitconf_t xecfg = { xdemitconf_t xecfg = {
XDL_EMIT_BDIFFHUNK, /* flags */ XDL_EMIT_BDIFFHUNK, /* flags */
hunk_consumer, /* hunk_consume_func */ hunk_consumer, /* hunk_consume_func */
}; };
xdemitcb_t ecb = { xdemitcb_t ecb = {
NULL, /* priv */ NULL, /* priv */
}; };
if (!PyArg_ParseTuple(args, PY23("s#s#", "y#y#"), &a.ptr, &la, &b.ptr, if (!PyArg_ParseTuple(args, PY23("s#s#", "y#y#"), &a.ptr, &la, &b.ptr,
&lb)) &lb)) {
return NULL; return NULL;
}
a.size = la; a.size = la;
b.size = lb; b.size = lb;
rl = PyList_New(0); rl = PyList_New(0);
if (!rl) if (!rl) {
return PyErr_NoMemory(); return PyErr_NoMemory();
}
ecb.priv = rl; ecb.priv = rl;
if (xdl_diff(&a, &b, &xpp, &xecfg, &ecb) != 0) { if (xdl_diff(&a, &b, &xpp, &xecfg, &ecb) != 0) {
Py_DECREF(rl); Py_DECREF(rl);
return PyErr_NoMemory(); return PyErr_NoMemory();
} }

mercurial/cext/charencode.c

PyObject *unhexlify(const char *str, Py_ssize_t len) PyObject *unhexlify(const char *str, Py_ssize_t len)
{ {
PyObject *ret; PyObject *ret;
char *d; char *d;
Py_ssize_t i; Py_ssize_t i;
ret = PyBytes_FromStringAndSize(NULL, len / 2); ret = PyBytes_FromStringAndSize(NULL, len / 2);
if (!ret) if (!ret) {
return NULL; return NULL;
}
d = PyBytes_AsString(ret); d = PyBytes_AsString(ret);
for (i = 0; i < len;) { for (i = 0; i < len;) {
int hi = hexdigit(str, i++); int hi = hexdigit(str, i++);
int lo = hexdigit(str, i++); int lo = hexdigit(str, i++);
*d++ = (hi << 4) | lo; *d++ = (hi << 4) | lo;
} }
return ret; return ret;
} }
PyObject *isasciistr(PyObject *self, PyObject *args) PyObject *isasciistr(PyObject *self, PyObject *args)
{ {
const char *buf; const char *buf;
Py_ssize_t i, len; Py_ssize_t i, len;
if (!PyArg_ParseTuple(args, PY23("s#:isasciistr", "y#:isasciistr"), if (!PyArg_ParseTuple(args, PY23("s#:isasciistr", "y#:isasciistr"),
&buf, &len)) &buf, &len)) {
return NULL; return NULL;
}
i = 0; i = 0;
/* char array in PyStringObject should be at least 4-byte aligned */ /* char array in PyStringObject should be at least 4-byte aligned */
if (((uintptr_t)buf & 3) == 0) { if (((uintptr_t)buf & 3) == 0) {
const uint32_t *p = (const uint32_t *)buf; const uint32_t *p = (const uint32_t *)buf;
for (; i < len / 4; i++) { for (; i < len / 4; i++) {
if (p[i] & 0x80808080U) if (p[i] & 0x80808080U) {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}
i *= 4; i *= 4;
} }
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 * static inline PyObject *
_asciitransform(PyObject *str_obj, const char table[128], PyObject *fallback_fn) _asciitransform(PyObject *str_obj, const char table[128], 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( ret = PyObject_CallFunctionObjArgs(
quit: quit:
Py_XDECREF(newobj); Py_XDECREF(newobj);
return ret; return ret;
} }
PyObject *asciilower(PyObject *self, PyObject *args) PyObject *asciilower(PyObject *self, PyObject *args)
{ {
PyObject *str_obj; PyObject *str_obj;
if (!PyArg_ParseTuple(args, "O!:asciilower", &PyBytes_Type, &str_obj)) if (!PyArg_ParseTuple(args, "O!:asciilower", &PyBytes_Type, &str_obj)) {
return NULL; return NULL;
}
return _asciitransform(str_obj, lowertable, NULL); return _asciitransform(str_obj, lowertable, NULL);
} }
PyObject *asciiupper(PyObject *self, PyObject *args) PyObject *asciiupper(PyObject *self, PyObject *args)
{ {
PyObject *str_obj; PyObject *str_obj;
if (!PyArg_ParseTuple(args, "O!:asciiupper", &PyBytes_Type, &str_obj)) if (!PyArg_ParseTuple(args, "O!:asciiupper", &PyBytes_Type, &str_obj)) {
return NULL; return NULL;
}
return _asciitransform(str_obj, uppertable, NULL); return _asciitransform(str_obj, uppertable, NULL);
} }
PyObject *make_file_foldmap(PyObject *self, PyObject *args) PyObject *make_file_foldmap(PyObject *self, PyObject *args)
{ {
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", &PyDict_Type, if (!PyArg_ParseTuple(args, "O!O!O!:make_file_foldmap", &PyDict_Type,
&dmap, &PyInt_Type, &spec_obj, &PyFunction_Type, &dmap, &PyInt_Type, &spec_obj, &PyFunction_Type,
&normcase_fallback)) &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:
table = uppertable; table = uppertable;
break; break;
case NORMCASE_OTHER: case NORMCASE_OTHER:
table = NULL; table = NULL;
break; break;
default: default:
PyErr_SetString(PyExc_TypeError, "invalid normcasespec"); PyErr_SetString(PyExc_TypeError, "invalid normcasespec");
goto quit; goto quit;
} }
/* Add some more entries to deal with additions outside this /* Add some more entries to deal with additions outside this
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_DECREF(normed); Py_DECREF(normed);
} }
} }
return file_foldmap; return file_foldmap;
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", &PyBytes_Type, if (!PyArg_ParseTuple(args, "O!i:jsonescapeu8fast", &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;
} }

mercurial/cext/mpatch.c

struct mpatch_flist *cpygetitem(void *bins, ssize_t pos) struct mpatch_flist *cpygetitem(void *bins, ssize_t pos)
{ {
Py_buffer buffer; Py_buffer buffer;
struct mpatch_flist *res = NULL; struct mpatch_flist *res = NULL;
int r; int r;
PyObject *tmp = PyList_GetItem((PyObject *)bins, pos); PyObject *tmp = PyList_GetItem((PyObject *)bins, pos);
if (!tmp) if (!tmp) {
return NULL; return NULL;
if (PyObject_GetBuffer(tmp, &buffer, PyBUF_CONTIG_RO)) }
if (PyObject_GetBuffer(tmp, &buffer, PyBUF_CONTIG_RO)) {
return NULL; return NULL;
}
if ((r = mpatch_decode(buffer.buf, buffer.len, &res)) < 0) { if ((r = mpatch_decode(buffer.buf, buffer.len, &res)) < 0) {
if (!PyErr_Occurred()) if (!PyErr_Occurred()) {
setpyerr(r); setpyerr(r);
}
res = NULL; res = NULL;
} }
PyBuffer_Release(&buffer); PyBuffer_Release(&buffer);
return res; return res;
} }
static PyObject *patches(PyObject *self, PyObject *args) static PyObject *patches(PyObject *self, PyObject *args)
{ {
PyObject *text, *bins, *result; PyObject *text, *bins, *result;
struct mpatch_flist *patch; struct mpatch_flist *patch;
Py_buffer buffer; Py_buffer buffer;
int r = 0; int r = 0;
char *out; char *out;
Py_ssize_t len, outlen; Py_ssize_t len, outlen;
if (!PyArg_ParseTuple(args, "OO:mpatch", &text, &bins)) if (!PyArg_ParseTuple(args, "OO:mpatch", &text, &bins)) {
return NULL; return NULL;
}
len = PyList_Size(bins); len = PyList_Size(bins);
if (!len) { if (!len) {
/* nothing to do */ /* nothing to do */
Py_INCREF(text); Py_INCREF(text);
return text; return text;
} }
if (PyObject_GetBuffer(text, &buffer, PyBUF_CONTIG_RO)) { if (PyObject_GetBuffer(text, &buffer, PyBUF_CONTIG_RO)) {
return NULL; return NULL;
} }
patch = mpatch_fold(bins, cpygetitem, 0, len); patch = mpatch_fold(bins, cpygetitem, 0, len);
if (!patch) { /* error already set or memory error */ if (!patch) { /* error already set or memory error */
if (!PyErr_Occurred()) if (!PyErr_Occurred()) {
PyErr_NoMemory(); PyErr_NoMemory();
}
result = NULL; result = NULL;
goto cleanup; goto cleanup;
} }
outlen = mpatch_calcsize(buffer.len, patch); outlen = mpatch_calcsize(buffer.len, patch);
if (outlen < 0) { if (outlen < 0) {
r = (int)outlen; r = (int)outlen;
result = NULL; result = NULL;
/* clang-format on */ /* clang-format on */
if (r < 0) { if (r < 0) {
Py_DECREF(result); Py_DECREF(result);
result = NULL; result = NULL;
} }
cleanup: cleanup:
mpatch_lfree(patch); mpatch_lfree(patch);
PyBuffer_Release(&buffer); PyBuffer_Release(&buffer);
if (!result && !PyErr_Occurred()) if (!result && !PyErr_Occurred()) {
setpyerr(r); setpyerr(r);
}
return result; return result;
} }
/* calculate size of a patched file directly */ /* calculate size of a patched file directly */
static PyObject *patchedsize(PyObject *self, PyObject *args) static PyObject *patchedsize(PyObject *self, PyObject *args)
{ {
long orig, start, end, len, outlen = 0, last = 0, pos = 0; long orig, start, end, len, outlen = 0, last = 0, pos = 0;
Py_ssize_t patchlen; Py_ssize_t patchlen;
char *bin; char *bin;
if (!PyArg_ParseTuple(args, PY23("ls#", "ly#"), &orig, &bin, &patchlen)) if (!PyArg_ParseTuple(args, PY23("ls#", "ly#"), &orig, &bin,
&patchlen)) {
return NULL; return NULL;
}
while (pos >= 0 && pos < patchlen) { while (pos >= 0 && pos < patchlen) {
start = getbe32(bin + pos); start = getbe32(bin + pos);
end = getbe32(bin + pos + 4); end = getbe32(bin + pos + 4);
len = getbe32(bin + pos + 8); len = getbe32(bin + pos + 8);
if (start > end) if (start > end) {
break; /* sanity check */ break; /* sanity check */
}
pos += 12 + len; pos += 12 + len;
outlen += start - last; outlen += start - last;
last = end; last = end;
outlen += len; outlen += len;
} }
if (pos != patchlen) { if (pos != patchlen) {
if (!PyErr_Occurred()) if (!PyErr_Occurred()) {
PyErr_SetString(mpatch_Error, PyErr_SetString(mpatch_Error,
"patch cannot be decoded"); "patch cannot be decoded");
}
return NULL; return NULL;
} }
outlen += orig - last; outlen += orig - last;
return Py_BuildValue("l", outlen); return Py_BuildValue("l", outlen);
} }
static PyMethodDef methods[] = { static PyMethodDef methods[] = {

mercurial/cext/parsers.c

#endif #endif
static const char *const versionerrortext = "Python minor version mismatch"; static const char *const versionerrortext = "Python minor version mismatch";
static PyObject *dict_new_presized(PyObject *self, PyObject *args) static PyObject *dict_new_presized(PyObject *self, PyObject *args)
{ {
Py_ssize_t expected_size; Py_ssize_t expected_size;
if (!PyArg_ParseTuple(args, "n:make_presized_dict", &expected_size)) if (!PyArg_ParseTuple(args, "n:make_presized_dict", &expected_size)) {
return NULL; return NULL;
}
return _dict_new_presized(expected_size); return _dict_new_presized(expected_size);
} }
static inline dirstateTupleObject *make_dirstate_tuple(char state, int mode, static inline dirstateTupleObject *make_dirstate_tuple(char state, int mode,
int size, int mtime) int size, int mtime)
{ {
dirstateTupleObject *t = dirstateTupleObject *t =
PyObject_New(dirstateTupleObject, &dirstateTupleType); PyObject_New(dirstateTupleObject, &dirstateTupleType);
if (!t) if (!t) {
return NULL; return NULL;
}
t->state = state; t->state = state;
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
t->mtime = mtime; t->mtime = mtime;
return t; return t;
} }
static PyObject *dirstate_tuple_new(PyTypeObject *subtype, PyObject *args, static PyObject *dirstate_tuple_new(PyTypeObject *subtype, PyObject *args,
PyObject *kwds) PyObject *kwds)
{ {
/* We do all the initialization here and not a tp_init function because /* We do all the initialization here and not a tp_init function because
* dirstate_tuple is immutable. */ * dirstate_tuple is immutable. */
dirstateTupleObject *t; dirstateTupleObject *t;
char state; char state;
int size, mode, mtime; int size, mode, mtime;
if (!PyArg_ParseTuple(args, "ciii", &state, &mode, &size, &mtime)) if (!PyArg_ParseTuple(args, "ciii", &state, &mode, &size, &mtime)) {
return NULL; return NULL;
}
t = (dirstateTupleObject *)subtype->tp_alloc(subtype, 1); t = (dirstateTupleObject *)subtype->tp_alloc(subtype, 1);
if (!t) if (!t) {
return NULL; return NULL;
}
t->state = state; t->state = state;
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
t->mtime = mtime; t->mtime = mtime;
return (PyObject *)t; return (PyObject *)t;
} }
PyObject *fname = NULL, *cname = NULL, *entry = NULL; PyObject *fname = NULL, *cname = NULL, *entry = NULL;
char state, *cur, *str, *cpos; char state, *cur, *str, *cpos;
int mode, size, mtime; int mode, size, mtime;
unsigned int flen, len, pos = 40; unsigned int flen, len, pos = 40;
int readlen; int readlen;
if (!PyArg_ParseTuple( if (!PyArg_ParseTuple(
args, PY23("O!O!s#:parse_dirstate", "O!O!y#:parse_dirstate"), args, PY23("O!O!s#:parse_dirstate", "O!O!y#:parse_dirstate"),
&PyDict_Type, &dmap, &PyDict_Type, &cmap, &str, &readlen)) &PyDict_Type, &dmap, &PyDict_Type, &cmap, &str, &readlen)) {
goto quit; goto quit;
}
len = readlen; len = readlen;
/* read parents */ /* read parents */
if (len < 40) { if (len < 40) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"too little data for parents"); "too little data for parents");
goto quit; goto quit;
} }
parents = Py_BuildValue(PY23("s#s#", "y#y#"), str, 20, str + 20, 20); parents = Py_BuildValue(PY23("s#s#", "y#y#"), str, 20, str + 20, 20);
if (!parents) if (!parents) {
goto quit; goto quit;
}
/* read filenames */ /* read filenames */
while (pos >= 40 && pos < len) { while (pos >= 40 && pos < len) {
if (pos + 17 > len) { if (pos + 17 > len) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"overflow in dirstate"); "overflow in dirstate");
goto quit; goto quit;
} }
(PyObject *)make_dirstate_tuple(state, mode, size, mtime); (PyObject *)make_dirstate_tuple(state, mode, size, mtime);
cpos = memchr(cur, 0, flen); cpos = memchr(cur, 0, flen);
if (cpos) { if (cpos) {
fname = PyBytes_FromStringAndSize(cur, cpos - cur); fname = PyBytes_FromStringAndSize(cur, cpos - cur);
cname = PyBytes_FromStringAndSize( cname = PyBytes_FromStringAndSize(
cpos + 1, flen - (cpos - cur) - 1); cpos + 1, flen - (cpos - cur) - 1);
if (!fname || !cname || if (!fname || !cname ||
PyDict_SetItem(cmap, fname, cname) == -1 || PyDict_SetItem(cmap, fname, cname) == -1 ||
PyDict_SetItem(dmap, fname, entry) == -1) PyDict_SetItem(dmap, fname, entry) == -1) {
goto quit; goto quit;
}
Py_DECREF(cname); Py_DECREF(cname);
} else { } else {
fname = PyBytes_FromStringAndSize(cur, flen); fname = PyBytes_FromStringAndSize(cur, flen);
if (!fname || PyDict_SetItem(dmap, fname, entry) == -1) if (!fname ||
PyDict_SetItem(dmap, fname, entry) == -1) {
goto quit; goto quit;
} }
}
Py_DECREF(fname); Py_DECREF(fname);
Py_DECREF(entry); Py_DECREF(entry);
fname = cname = entry = NULL; fname = cname = entry = NULL;
pos += flen; pos += flen;
} }
ret = parents; ret = parents;
Py_INCREF(ret); Py_INCREF(ret);
* Build a set of non-normal and other parent entries from the dirstate dmap * Build a set of non-normal and other parent entries from the dirstate dmap
*/ */
static PyObject *nonnormalotherparententries(PyObject *self, PyObject *args) static PyObject *nonnormalotherparententries(PyObject *self, PyObject *args)
{ {
PyObject *dmap, *fname, *v; PyObject *dmap, *fname, *v;
PyObject *nonnset = NULL, *otherpset = NULL, *result = NULL; PyObject *nonnset = NULL, *otherpset = NULL, *result = NULL;
Py_ssize_t pos; Py_ssize_t pos;
if (!PyArg_ParseTuple(args, "O!:nonnormalentries", &PyDict_Type, &dmap)) if (!PyArg_ParseTuple(args, "O!:nonnormalentries", &PyDict_Type,
&dmap)) {
goto bail; goto bail;
}
nonnset = PySet_New(NULL); nonnset = PySet_New(NULL);
if (nonnset == NULL) if (nonnset == NULL) {
goto bail; goto bail;
}
otherpset = PySet_New(NULL); otherpset = PySet_New(NULL);
if (otherpset == NULL) if (otherpset == NULL) {
goto bail; goto bail;
}
pos = 0; pos = 0;
while (PyDict_Next(dmap, &pos, &fname, &v)) { while (PyDict_Next(dmap, &pos, &fname, &v)) {
dirstateTupleObject *t; dirstateTupleObject *t;
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 bail; goto bail;
} }
t = (dirstateTupleObject *)v; t = (dirstateTupleObject *)v;
if (t->state == 'n' && t->size == -2) { if (t->state == 'n' && t->size == -2) {
if (PySet_Add(otherpset, fname) == -1) { if (PySet_Add(otherpset, fname) == -1) {
goto bail; goto bail;
} }
} }
if (t->state == 'n' && t->mtime != -1) if (t->state == 'n' && t->mtime != -1) {
continue; continue;
if (PySet_Add(nonnset, fname) == -1) }
if (PySet_Add(nonnset, fname) == -1) {
goto bail; goto bail;
} }
}
result = Py_BuildValue("(OO)", nonnset, otherpset); result = Py_BuildValue("(OO)", nonnset, otherpset);
if (result == NULL) if (result == NULL) {
goto bail; goto bail;
}
Py_DECREF(nonnset); Py_DECREF(nonnset);
Py_DECREF(otherpset); Py_DECREF(otherpset);
return result; return result;
bail: bail:
Py_XDECREF(nonnset); Py_XDECREF(nonnset);
Py_XDECREF(otherpset); Py_XDECREF(otherpset);
Py_XDECREF(result); Py_XDECREF(result);
return NULL; return NULL;
} }
/* /*
* Efficiently pack a dirstate object into its on-disk format. * Efficiently pack a dirstate object into its on-disk format.
*/ */
static PyObject *pack_dirstate(PyObject *self, PyObject *args) static PyObject *pack_dirstate(PyObject *self, PyObject *args)
{ {
PyObject *packobj = NULL; PyObject *packobj = NULL;
PyObject *map, *copymap, *pl, *mtime_unset = NULL; PyObject *map, *copymap, *pl, *mtime_unset = NULL;
Py_ssize_t nbytes, pos, l; Py_ssize_t nbytes, pos, l;
PyObject *k, *v = NULL, *pn; PyObject *k, *v = NULL, *pn;
char *p, *s; char *p, *s;
int now; int now;
if (!PyArg_ParseTuple(args, "O!O!O!i:pack_dirstate", &PyDict_Type, &map, if (!PyArg_ParseTuple(args, "O!O!O!i:pack_dirstate", &PyDict_Type, &map,
&PyDict_Type, &copymap, &PyTuple_Type, &pl, &now)) &PyDict_Type, &copymap, &PyTuple_Type, &pl,
&now)) {
return NULL; return NULL;
}
if (PyTuple_Size(pl) != 2) { if (PyTuple_Size(pl) != 2) {
PyErr_SetString(PyExc_TypeError, "expected 2-element tuple"); PyErr_SetString(PyExc_TypeError, "expected 2-element tuple");
return NULL; return NULL;
} }
/* Figure out how much we need to allocate. */ /* Figure out how much we need to allocate. */
for (nbytes = 40, pos = 0; PyDict_Next(map, &pos, &k, &v);) { for (nbytes = 40, pos = 0; PyDict_Next(map, &pos, &k, &v);) {
"expected string key"); "expected string key");
goto bail; goto bail;
} }
nbytes += PyBytes_GET_SIZE(c) + 1; nbytes += PyBytes_GET_SIZE(c) + 1;
} }
} }
packobj = PyBytes_FromStringAndSize(NULL, nbytes); packobj = PyBytes_FromStringAndSize(NULL, nbytes);
if (packobj == NULL) if (packobj == NULL) {
goto bail; goto bail;
}
p = PyBytes_AS_STRING(packobj); p = PyBytes_AS_STRING(packobj);
pn = PyTuple_GET_ITEM(pl, 0); pn = PyTuple_GET_ITEM(pl, 0);
if (PyBytes_AsStringAndSize(pn, &s, &l) == -1 || l != 20) { if (PyBytes_AsStringAndSize(pn, &s, &l) == -1 || l != 20) {
PyErr_SetString(PyExc_TypeError, "expected a 20-byte hash"); PyErr_SetString(PyExc_TypeError, "expected a 20-byte hash");
goto bail; goto bail;
} }
size = tuple->size; size = tuple->size;
mtime = tuple->mtime; mtime = tuple->mtime;
if (state == 'n' && mtime == now) { if (state == 'n' && mtime == now) {
/* See pure/parsers.py:pack_dirstate for why we do /* See pure/parsers.py:pack_dirstate for why we do
* this. */ * this. */
mtime = -1; mtime = -1;
mtime_unset = (PyObject *)make_dirstate_tuple( mtime_unset = (PyObject *)make_dirstate_tuple(
state, mode, size, mtime); state, mode, size, mtime);
if (!mtime_unset) if (!mtime_unset) {
goto bail; goto bail;
if (PyDict_SetItem(map, k, mtime_unset) == -1) }
if (PyDict_SetItem(map, k, mtime_unset) == -1) {
goto bail; goto bail;
}
Py_DECREF(mtime_unset); Py_DECREF(mtime_unset);
mtime_unset = NULL; mtime_unset = NULL;
} }
*p++ = state; *p++ = state;
putbe32((uint32_t)mode, p); putbe32((uint32_t)mode, p);
putbe32((uint32_t)size, p + 4); putbe32((uint32_t)size, p + 4);
putbe32((uint32_t)mtime, p + 8); putbe32((uint32_t)mtime, p + 8);
t = p + 12; t = p + 12;
* recompile. Note that this means the pure-Python version of parsers * recompile. Note that this means the pure-Python version of parsers
* should not have this module constant. */ * should not have this module constant. */
PyModule_AddStringConstant(mod, "versionerrortext", versionerrortext); PyModule_AddStringConstant(mod, "versionerrortext", versionerrortext);
dirs_module_init(mod); dirs_module_init(mod);
manifest_module_init(mod); manifest_module_init(mod);
revlog_module_init(mod); revlog_module_init(mod);
if (PyType_Ready(&dirstateTupleType) < 0) if (PyType_Ready(&dirstateTupleType) < 0) {
return; return;
}
Py_INCREF(&dirstateTupleType); Py_INCREF(&dirstateTupleType);
PyModule_AddObject(mod, "dirstatetuple", PyModule_AddObject(mod, "dirstatetuple",
(PyObject *)&dirstateTupleType); (PyObject *)&dirstateTupleType);
} }
static int check_python_version(void) static int check_python_version(void)
{ {
PyObject *sys = PyImport_ImportModule("sys"), *ver; PyObject *sys = PyImport_ImportModule("sys"), *ver;
long hexversion; long hexversion;
if (!sys) if (!sys) {
return -1; return -1;
}
ver = PyObject_GetAttrString(sys, "hexversion"); ver = PyObject_GetAttrString(sys, "hexversion");
Py_DECREF(sys); Py_DECREF(sys);
if (!ver) if (!ver) {
return -1; return -1;
}
hexversion = PyInt_AsLong(ver); hexversion = PyInt_AsLong(ver);
Py_DECREF(ver); Py_DECREF(ver);
/* sys.hexversion is a 32-bit number by default, so the -1 case /* sys.hexversion is a 32-bit number by default, so the -1 case
* should only occur in unusual circumstances (e.g. if sys.hexversion * should only occur in unusual circumstances (e.g. if sys.hexversion
* is manually set to an invalid value). */ * is manually set to an invalid value). */
if ((hexversion == -1) || (hexversion >> 16 != PY_VERSION_HEX >> 16)) { if ((hexversion == -1) || (hexversion >> 16 != PY_VERSION_HEX >> 16)) {
PyErr_Format(PyExc_ImportError, PyErr_Format(PyExc_ImportError,
"%s: The Mercurial extension " "%s: The Mercurial extension "
module_init(mod); module_init(mod);
return mod; return mod;
} }
#else #else
PyMODINIT_FUNC initparsers(void) PyMODINIT_FUNC initparsers(void)
{ {
PyObject *mod; PyObject *mod;
if (check_python_version() == -1) if (check_python_version() == -1) {
return; return;
}
mod = Py_InitModule3("parsers", methods, parsers_doc); mod = Py_InitModule3("parsers", methods, parsers_doc);
module_init(mod); module_init(mod);
} }
#endif #endif

mercurial/cext/pathencode.c

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;
}
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;
case DDEFAULT: case DDEFAULT:
if (src[i] == '.') if (src[i] == '.') {
state = DDOT; state = DDOT;
}
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
break; break;
} }
} }
return destlen; return destlen;
} }
PyObject *encodedir(PyObject *self, PyObject *args) PyObject *encodedir(PyObject *self, PyObject *args)
{ {
Py_ssize_t len, newlen; Py_ssize_t len, newlen;
PyObject *pathobj, *newobj; PyObject *pathobj, *newobj;
char *path; char *path;
if (!PyArg_ParseTuple(args, "O:encodedir", &pathobj)) if (!PyArg_ParseTuple(args, "O:encodedir", &pathobj)) {
return NULL; return NULL;
}
if (PyBytes_AsStringAndSize(pathobj, &path, &len) == -1) { if (PyBytes_AsStringAndSize(pathobj, &path, &len) == -1) {
PyErr_SetString(PyExc_TypeError, "expected a string"); PyErr_SetString(PyExc_TypeError, "expected a string");
return NULL; return NULL;
} }
newlen = len ? _encodedir(NULL, 0, path, len + 1) : 1; newlen = len ? _encodedir(NULL, 0, path, len + 1) : 1;
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 '1':
case '2': case '2':
case '3': case '3':
case '4': case '4':
case '5': case '5':
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++]);
break; break;
default: default:
state = DEFAULT; state = DEFAULT;
charcopy(dest, &destlen, destsize, ' '); charcopy(dest, &destlen, destsize, ' ');
break; break;
} }
break; break;
case DEFAULT: case DEFAULT:
while (inset(onebyte, src[i])) { while (inset(onebyte, src[i])) {
charcopy(dest, &destlen, destsize, src[i++]); charcopy(dest, &destlen, destsize, src[i++]);
if (i == len) if (i == len) {
goto done; goto done;
} }
}
switch (src[i]) { switch (src[i]) {
case '.': case '.':
state = DOT; state = DOT;
i++; i++;
break; break;
case ' ': case ' ':
state = SPACE; state = SPACE;
i++; i++;
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 const uint32_t onebyte[8] = {1, 0x2bfffbfb, 0xe8000001, static const uint32_t onebyte[8] = {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);
else } else {
escape3(dest, &destlen, destsize, src[i]); escape3(dest, &destlen, destsize, src[i]);
} }
}
return destlen; return destlen;
} }
PyObject *lowerencode(PyObject *self, PyObject *args) PyObject *lowerencode(PyObject *self, PyObject *args)
{ {
char *path; char *path;
Py_ssize_t len, newlen; Py_ssize_t len, newlen;
PyObject *ret; PyObject *ret;
if (!PyArg_ParseTuple(args, PY23("s#:lowerencode", "y#:lowerencode"), if (!PyArg_ParseTuple(args, PY23("s#:lowerencode", "y#:lowerencode"),
&path, &len)) &path, &len)) {
return NULL; return NULL;
}
newlen = _lowerencode(NULL, 0, path, len); newlen = _lowerencode(NULL, 0, path, len);
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, const char *src, static Py_ssize_t auxencode(char *dest, size_t destsize, const char *src,
Py_ssize_t len) Py_ssize_t len)
{ {
static const Py_ssize_t maxshortdirslen = 68; static const Py_ssize_t maxshortdirslen = 68;
char *dest; char *dest;
PyObject *ret; PyObject *ret;
Py_ssize_t i, d, p, lastslash = len - 1, lastdot = -1; Py_ssize_t i, d, p, lastslash = len - 1, lastdot = -1;
Py_ssize_t destsize, destlen = 0, slop, used; Py_ssize_t destsize, destlen = 0, slop, used;
while (lastslash >= 0 && src[lastslash] != '/') { while (lastslash >= 0 && src[lastslash] != '/') {
if (src[lastslash] == '.' && lastdot == -1) if (src[lastslash] == '.' && lastdot == -1) {
lastdot = lastslash; lastdot = lastslash;
}
lastslash--; lastslash--;
} }
#if 0 #if 0
/* All paths should end in a suffix of ".i" or ".d". /* All paths should end in a suffix of ".i" or ".d".
Unfortunately, the file names in test-hybridencode.py Unfortunately, the file names in test-hybridencode.py
violate this rule. */ violate this rule. */
if (lastdot != len - 3) { if (lastdot != len - 3) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"suffix missing or wrong length"); "suffix missing or wrong length");
return NULL; return NULL;
} }
#endif #endif
/* If src contains a suffix, we will append it to the end of /* If src contains a suffix, we will append it to the end of
the new string, so make room. */ the new string, so make room. */
destsize = 120; destsize = 120;
if (lastdot >= 0) if (lastdot >= 0) {
destsize += len - lastdot - 1; destsize += len - lastdot - 1;
}
ret = PyBytes_FromStringAndSize(NULL, destsize); ret = PyBytes_FromStringAndSize(NULL, destsize);
if (ret == NULL) if (ret == NULL) {
return NULL; return NULL;
}
dest = PyBytes_AS_STRING(ret); dest = PyBytes_AS_STRING(ret);
memcopy(dest, &destlen, destsize, "dh/", 3); memcopy(dest, &destlen, destsize, "dh/", 3);
/* Copy up to dirprefixlen bytes of each path component, up to /* Copy up to dirprefixlen bytes of each path component, up to
a limit of maxshortdirslen bytes. */ a limit of maxshortdirslen bytes. */
for (i = d = p = 0; i < lastslash; i++, p++) { for (i = d = p = 0; i < lastslash; i++, p++) {
if (src[i] == '/') { if (src[i] == '/') {
char d = dest[destlen - 1]; char d = dest[destlen - 1];
/* After truncation, a directory name may end /* After truncation, a directory name may end
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
if (destlen > maxshortdirslen + 3) * beginning */
}
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] != '/');
}
if (destlen > 3) { if (destlen > 3) {
if (lastslash > 0) { if (lastslash > 0) {
char d = dest[destlen - 1]; char d = dest[destlen - 1];
/* The last directory component may be /* The last directory component may be
truncated, so make it safe. */ truncated, so make it safe. */
if (d == '.' || d == ' ') if (d == '.' || d == ' ') {
dest[destlen - 1] = '_'; dest[destlen - 1] = '_';
} }
}
charcopy(dest, &destlen, destsize, '/'); charcopy(dest, &destlen, destsize, '/');
} }
/* Add a prefix of the original file's name. Its length /* Add a prefix of the original file's name. Its length
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;
} }
/* /*
"module 'hashlib' has no " "module 'hashlib' has no "
"attribute 'sha1' in pathencode"); "attribute 'sha1' in pathencode");
return -1; return -1;
} }
} }
shaobj = PyObject_CallFunction(shafunc, PY23("s#", "y#"), str, len); shaobj = PyObject_CallFunction(shafunc, PY23("s#", "y#"), 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;
} }
baselen = (len - 5) * 3; baselen = (len - 5) * 3;
if (baselen >= MAXENCODE) { if (baselen >= MAXENCODE) {
PyErr_SetString(PyExc_ValueError, "string too long"); PyErr_SetString(PyExc_ValueError, "string too long");
return NULL; return NULL;
} }
dirlen = _encodedir(dired, baselen, src, len); dirlen = _encodedir(dired, baselen, src, len);
if (sha1hash(sha, dired, dirlen - 1) == -1) if (sha1hash(sha, dired, dirlen - 1) == -1) {
return NULL; return NULL;
}
lowerlen = _lowerencode(lowered, baselen, dired + 5, dirlen - 5); lowerlen = _lowerencode(lowered, baselen, dired + 5, dirlen - 5);
auxlen = auxencode(auxed, baselen, lowered, lowerlen); auxlen = auxencode(auxed, baselen, lowered, lowerlen);
return hashmangle(auxed, auxlen, sha); return hashmangle(auxed, auxlen, sha);
} }
PyObject *pathencode(PyObject *self, PyObject *args) PyObject *pathencode(PyObject *self, PyObject *args)
{ {
Py_ssize_t len, newlen; Py_ssize_t len, newlen;
PyObject *pathobj, *newobj; PyObject *pathobj, *newobj;
char *path; char *path;
if (!PyArg_ParseTuple(args, "O:pathencode", &pathobj)) if (!PyArg_ParseTuple(args, "O:pathencode", &pathobj)) {
return NULL; return NULL;
}
if (PyBytes_AsStringAndSize(pathobj, &path, &len) == -1) { if (PyBytes_AsStringAndSize(pathobj, &path, &len) == -1) {
PyErr_SetString(PyExc_TypeError, "expected a string"); PyErr_SetString(PyExc_TypeError, "expected a string");
return NULL; return NULL;
} }
if (len > maxstorepathlen) if (len > maxstorepathlen) {
newlen = maxstorepathlen + 2; newlen = maxstorepathlen + 2;
else } else {
newlen = len ? basicencode(NULL, 0, path, len + 1) : 1; newlen = len ? basicencode(NULL, 0, path, len + 1) : 1;
}
if (newlen <= maxstorepathlen + 1) { if (newlen <= maxstorepathlen + 1) {
if (newlen == len + 1) { if (newlen == len + 1) {
Py_INCREF(pathobj); Py_INCREF(pathobj);
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)--;
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;
} }

mercurial/mpatch.c

#else #else
#include <stdbool.h> #include <stdbool.h>
#endif #endif
static struct mpatch_flist *lalloc(ssize_t size) static struct mpatch_flist *lalloc(ssize_t size)
{ {
struct mpatch_flist *a = NULL; struct mpatch_flist *a = NULL;
if (size < 1) if (size < 1) {
size = 1; size = 1;
}
a = (struct mpatch_flist *)malloc(sizeof(struct mpatch_flist)); a = (struct mpatch_flist *)malloc(sizeof(struct mpatch_flist));
if (a) { if (a) {
a->base = (struct mpatch_frag *)malloc( a->base = (struct mpatch_frag *)malloc(
sizeof(struct mpatch_frag) * size); sizeof(struct mpatch_frag) * size);
if (a->base) { if (a->base) {
a->head = a->tail = a->base; a->head = a->tail = a->base;
return a; return a;
static int gather(struct mpatch_flist *dest, struct mpatch_flist *src, int cut, static int gather(struct mpatch_flist *dest, struct mpatch_flist *src, int cut,
int offset) int offset)
{ {
struct mpatch_frag *d = dest->tail, *s = src->head; struct mpatch_frag *d = dest->tail, *s = src->head;
int postend, c, l; int postend, c, l;
while (s != src->tail) { while (s != src->tail) {
int soffset = s->start; int soffset = s->start;
if (!safeadd(offset, &soffset)) if (!safeadd(offset, &soffset)) {
break; /* add would overflow, oh well */ break; /* add would overflow, oh well */
if (soffset >= cut) }
if (soffset >= cut) {
break; /* we've gone far enough */ break; /* we've gone far enough */
}
postend = offset; postend = offset;
if (!safeadd(s->start, &postend) || if (!safeadd(s->start, &postend) ||
!safeadd(s->len, &postend)) { !safeadd(s->len, &postend)) {
break; break;
} }
if (postend <= cut) { if (postend <= cut) {
/* save this hunk */ /* save this hunk */
} }
*d++ = *s++; *d++ = *s++;
} else { } else {
/* break up this hunk */ /* break up this hunk */
c = cut; c = cut;
if (!safesub(offset, &c)) { if (!safesub(offset, &c)) {
break; break;
} }
if (s->end < c) if (s->end < c) {
c = s->end; c = s->end;
}
l = cut - offset - s->start; l = cut - offset - s->start;
if (s->len < l) if (s->len < l) {
l = s->len; l = s->len;
}
offset += s->start + l - c; offset += s->start + l - c;
d->start = s->start; d->start = s->start;
d->end = c; d->end = c;
d->len = l; d->len = l;
d->data = s->data; d->data = s->data;
d++; d++;
struct mpatch_frag *s = src->head; struct mpatch_frag *s = src->head;
int postend, c, l; int postend, c, l;
while (s != src->tail) { while (s != src->tail) {
int cmpcut = s->start; int cmpcut = s->start;
if (!safeadd(offset, &cmpcut)) { if (!safeadd(offset, &cmpcut)) {
break; break;
} }
if (cmpcut >= cut) if (cmpcut >= cut) {
break; break;
}
postend = offset; postend = offset;
if (!safeadd(s->start, &postend)) { if (!safeadd(s->start, &postend)) {
break; break;
} }
if (!safeadd(s->len, &postend)) { if (!safeadd(s->len, &postend)) {
break; break;
} }
break; break;
} }
s++; s++;
} else { } else {
c = cut; c = cut;
if (!safesub(offset, &c)) { if (!safesub(offset, &c)) {
break; break;
} }
if (s->end < c) if (s->end < c) {
c = s->end; c = s->end;
}
l = cut - offset - s->start; l = cut - offset - s->start;
if (s->len < l) if (s->len < l) {
l = s->len; l = s->len;
}
offset += s->start + l - c; offset += s->start + l - c;
s->start = c; s->start = c;
s->len = s->len - l; s->len = s->len - l;
s->data = s->data + l; s->data = s->data + l;
break; break;
} }
} }
src->head = s; src->head = s;
return offset; return offset;
} }
/* combine hunk lists a and b, while adjusting b for offset changes in a/ /* combine hunk lists a and b, while adjusting b for offset changes in a/
this deletes a and b and returns the resultant list. */ this deletes a and b and returns the resultant list. */
static struct mpatch_flist *combine(struct mpatch_flist *a, static struct mpatch_flist *combine(struct mpatch_flist *a,
struct mpatch_flist *b) struct mpatch_flist *b)
{ {
struct mpatch_flist *c = NULL; struct mpatch_flist *c = NULL;
struct mpatch_frag *bh, *ct; struct mpatch_frag *bh, *ct;
int offset = 0, post; int offset = 0, post;
if (a && b) if (a && b) {
c = lalloc((lsize(a) + lsize(b)) * 2); c = lalloc((lsize(a) + lsize(b)) * 2);
}
if (c) { if (c) {
for (bh = b->head; bh != b->tail; bh++) { for (bh = b->head; bh != b->tail; bh++) {
/* save old hunks */ /* save old hunks */
offset = gather(c, a, bh->start, offset); offset = gather(c, a, bh->start, offset);
/* discard replaced hunks */ /* discard replaced hunks */
int mpatch_decode(const char *bin, ssize_t len, struct mpatch_flist **res) int mpatch_decode(const char *bin, ssize_t len, struct mpatch_flist **res)
{ {
struct mpatch_flist *l; struct mpatch_flist *l;
struct mpatch_frag *lt; struct mpatch_frag *lt;
int pos = 0; int pos = 0;
/* assume worst case size, we won't have many of these lists */ /* assume worst case size, we won't have many of these lists */
l = lalloc(len / 12 + 1); l = lalloc(len / 12 + 1);
if (!l) if (!l) {
return MPATCH_ERR_NO_MEM; return MPATCH_ERR_NO_MEM;
}
lt = l->tail; lt = l->tail;
/* We check against len-11 to ensure we have at least 12 bytes /* We check against len-11 to ensure we have at least 12 bytes
left in the patch so we can read our three be32s out of it. */ left in the patch so we can read our three be32s out of it. */
while (pos >= 0 && pos < (len - 11)) { while (pos >= 0 && pos < (len - 11)) {
lt->start = getbe32(bin + pos); lt->start = getbe32(bin + pos);
lt->end = getbe32(bin + pos + 4); lt->end = getbe32(bin + pos + 4);
lt->len = getbe32(bin + pos + 8); lt->len = getbe32(bin + pos + 8);
if (lt->start < 0 || lt->start > lt->end || lt->len < 0) if (lt->start < 0 || lt->start > lt->end || lt->len < 0) {
break; /* sanity check */ break; /* sanity check */
}
if (!safeadd(12, &pos)) { if (!safeadd(12, &pos)) {
break; break;
} }
lt->data = bin + pos; lt->data = bin + pos;
if (!safeadd(lt->len, &pos)) { if (!safeadd(lt->len, &pos)) {
break; break;
} }
lt++; lt++;

rust/chg/src/sighandlers.c

pid_t killpid = peerpgid > 1 ? -peerpgid : peerpid; pid_t killpid = peerpgid > 1 ? -peerpgid : peerpid;
(void)kill(killpid, sig); (void)kill(killpid, sig);
} }
static void handlestopsignal(int sig) static void handlestopsignal(int sig)
{ {
sigset_t unblockset, oldset; sigset_t unblockset, oldset;
struct sigaction sa, oldsa; struct sigaction sa, oldsa;
if (sigemptyset(&unblockset) < 0) if (sigemptyset(&unblockset) < 0) {
return; return;
if (sigaddset(&unblockset, sig) < 0) }
if (sigaddset(&unblockset, sig) < 0) {
return; return;
}
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL; sa.sa_handler = SIG_DFL;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigemptyset(&sa.sa_mask) < 0) if (sigemptyset(&sa.sa_mask) < 0) {
return; return;
}
forwardsignal(sig); forwardsignal(sig);
if (raise(sig) < 0) /* resend to self */ if (raise(sig) < 0) { /* resend to self */
return; return;
if (sigaction(sig, &sa, &oldsa) < 0) }
if (sigaction(sig, &sa, &oldsa) < 0) {
return; return;
if (sigprocmask(SIG_UNBLOCK, &unblockset, &oldset) < 0) }
if (sigprocmask(SIG_UNBLOCK, &unblockset, &oldset) < 0) {
return; return;
}
/* resent signal will be handled before sigprocmask() returns */ /* resent signal will be handled before sigprocmask() returns */
if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0) if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0) {
return; return;
if (sigaction(sig, &oldsa, NULL) < 0) }
if (sigaction(sig, &oldsa, NULL) < 0) {
return; return;
} }
}
/* /*
* Installs signal handlers. * Installs signal handlers.
* *
* Returns 0 on success, -1 on error and errno is set appropriately. * Returns 0 on success, -1 on error and errno is set appropriately.
* Installed handlers wouldn't be cleaned up on error. * Installed handlers wouldn't be cleaned up on error.
*/ */
int setupsignalhandler(pid_t pid, pid_t pgid) int setupsignalhandler(pid_t pid, pid_t pgid)
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
/* deadly signals meant to be sent to a process group: /* deadly signals meant to be sent to a process group:
* - SIGHUP: usually generated by the kernel, when termination of a * - SIGHUP: usually generated by the kernel, when termination of a
* process causes that process group to become orphaned * process causes that process group to become orphaned
* - SIGINT: usually generated by the terminal */ * - SIGINT: usually generated by the terminal */
sa.sa_handler = forwardsignaltogroup; sa.sa_handler = forwardsignaltogroup;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigemptyset(&sa.sa_mask) < 0) if (sigemptyset(&sa.sa_mask) < 0) {
return -1; return -1;
if (sigaction(SIGHUP, &sa, NULL) < 0) }
if (sigaction(SIGHUP, &sa, NULL) < 0) {
return -1; return -1;
if (sigaction(SIGINT, &sa, NULL) < 0) }
if (sigaction(SIGINT, &sa, NULL) < 0) {
return -1; return -1;
}
/* terminate frontend by double SIGTERM in case of server freeze */ /* terminate frontend by double SIGTERM in case of server freeze */
sa.sa_handler = forwardsignal; sa.sa_handler = forwardsignal;
sa.sa_flags |= SA_RESETHAND; sa.sa_flags |= SA_RESETHAND;
if (sigaction(SIGTERM, &sa, NULL) < 0) if (sigaction(SIGTERM, &sa, NULL) < 0) {
return -1; return -1;
}
/* notify the worker about window resize events */ /* notify the worker about window resize events */
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGWINCH, &sa, NULL) < 0) if (sigaction(SIGWINCH, &sa, NULL) < 0) {
return -1; return -1;
}
/* forward user-defined signals */ /* forward user-defined signals */
if (sigaction(SIGUSR1, &sa, NULL) < 0) if (sigaction(SIGUSR1, &sa, NULL) < 0) {
return -1; return -1;
if (sigaction(SIGUSR2, &sa, NULL) < 0) }
if (sigaction(SIGUSR2, &sa, NULL) < 0) {
return -1; return -1;
}
/* propagate job control requests to worker */ /* propagate job control requests to worker */
sa.sa_handler = forwardsignal; sa.sa_handler = forwardsignal;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGCONT, &sa, NULL) < 0) if (sigaction(SIGCONT, &sa, NULL) < 0) {
return -1; return -1;
}
sa.sa_handler = handlestopsignal; sa.sa_handler = handlestopsignal;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGTSTP, &sa, NULL) < 0) if (sigaction(SIGTSTP, &sa, NULL) < 0) {
return -1; return -1;
}
return 0; return 0;
} }
/* /*
* Restores signal handlers to the default, and masks SIGINT. * Restores signal handlers to the default, and masks SIGINT.
* *
* Returns 0 on success, -1 on error and errno is set appropriately. * Returns 0 on success, -1 on error and errno is set appropriately.
*/ */
int restoresignalhandler(void) int restoresignalhandler(void)
{ {
struct sigaction sa; struct sigaction sa;
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL; sa.sa_handler = SIG_DFL;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigemptyset(&sa.sa_mask) < 0) if (sigemptyset(&sa.sa_mask) < 0) {
return -1; return -1;
}
if (sigaction(SIGHUP, &sa, NULL) < 0) if (sigaction(SIGHUP, &sa, NULL) < 0) {
return -1; return -1;
if (sigaction(SIGTERM, &sa, NULL) < 0) }
if (sigaction(SIGTERM, &sa, NULL) < 0) {
return -1; return -1;
if (sigaction(SIGWINCH, &sa, NULL) < 0) }
if (sigaction(SIGWINCH, &sa, NULL) < 0) {
return -1; return -1;
if (sigaction(SIGCONT, &sa, NULL) < 0) }
if (sigaction(SIGCONT, &sa, NULL) < 0) {
return -1; return -1;
if (sigaction(SIGTSTP, &sa, NULL) < 0) }
if (sigaction(SIGTSTP, &sa, NULL) < 0) {
return -1; return -1;
}
/* ignore Ctrl+C while shutting down to make pager exits cleanly */ /* ignore Ctrl+C while shutting down to make pager exits cleanly */
sa.sa_handler = SIG_IGN; sa.sa_handler = SIG_IGN;
if (sigaction(SIGINT, &sa, NULL) < 0) if (sigaction(SIGINT, &sa, NULL) < 0) {
return -1; return -1;
}
peerpid = 0; peerpid = 0;
return 0; return 0;
} }