upstream/mercurial-mirror Commit - r35977:9724f549

chg: enable clang-format on all .c and .h files...

Augie Fackler -

r35977:9724f549 default

parent child

contrib/chg/chg.c

0 +40 -40

             	const char **args;
             };
-            static void initcmdserveropts(struct cmdserveropts *opts) {
+            static void initcmdserveropts(struct cmdserveropts *opts)
+            {
             	memset(opts, 0, sizeof(struct cmdserveropts));
             }
-            static void freecmdserveropts(struct cmdserveropts *opts) {
+            static void freecmdserveropts(struct cmdserveropts *opts)
+            {
             	free(opts->args);
             	opts->args = NULL;
             	opts->argsize = 0;
             		const char *name;
             		size_t narg;
             	} flags[] = {
-            		{"--config", 1},
+            	    {"--config", 1},     {"--cwd", 1},       {"--repo", 1},
-            		{"--cwd", 1},
+            	    {"--repository", 1}, {"--traceback", 0}, {"-R", 1},
-            		{"--repo", 1},
-            		{"--repository", 1},
-            		{"--traceback", 0},
-            		{"-R", 1},
             	};
             	size_t i;
             	for (i = 0; i < sizeof(flags) / sizeof(flags[0]); ++i) {
             /*
              * Parse argv[] and put sensitive flags to opts->args
              */
-            static void setcmdserverargs(struct cmdserveropts *opts,
+            static void setcmdserverargs(struct cmdserveropts *opts, int argc,
-            			     int argc, const char *argv[])
+                                         const char *argv[])
             {
             	size_t i, step;
             	opts->argsize = 0;
             	for (i = 0, step = 1; i < (size_t)argc; i += step, step = 1) {
             		if (!argv[i])
-            			continue;  /* pass clang-analyse */
+            			continue; /* pass clang-analyse */
             		if (strcmp(argv[i], "--") == 0)
             			break;
             		size_t n = testsensitiveflag(argv[i]);
             		if (n == 0 || i + n > (size_t)argc)
             			continue;
-            		opts->args = reallocx(opts->args,
+            		opts->args =
-            				      (n + opts->argsize) * sizeof(char *));
+            		    reallocx(opts->args, (n + opts->argsize) * sizeof(char *));
             		memcpy(opts->args + opts->argsize, argv + i,
             		       sizeof(char *) * n);
             		opts->argsize += n;
             	r = snprintf(opts->sockname, sizeof(opts->sockname), sockfmt, basename);
             	if (r < 0 || (size_t)r >= sizeof(opts->sockname))
             		abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);
-            	r = snprintf(opts->initsockname, sizeof(opts->initsockname),
+            	r = snprintf(opts->initsockname, sizeof(opts->initsockname), "%s.%u",
-            			"%s.%u", opts->sockname, (unsigned)getpid());
+            	             opts->sockname, (unsigned)getpid());
             	if (r < 0 || (size_t)r >= sizeof(opts->initsockname))
             		abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);
             }
             	const char *hgcmd = gethgcmd();
             	const char *baseargv[] = {
-            		hgcmd,
+            	    hgcmd,
-            		"serve",
+            	    "serve",
-            		"--cmdserver", "chgunix",
+            	    "--cmdserver",
-            		"--address", opts->initsockname,
+            	    "chgunix",
-            		"--daemon-postexec", "chdir:/",
+            	    "--address",
+            	    opts->initsockname,
+            	    "--daemon-postexec",
+            	    "chdir:/",
             	};
             	size_t baseargvsize = sizeof(baseargv) / sizeof(baseargv[0]);
             	size_t argsize = baseargvsize + opts->argsize + 1;
             	debugmsg("try connect to %s repeatedly", opts->initsockname);
-            	unsigned int timeoutsec = 60;  /* default: 60 seconds */
+            	unsigned int timeoutsec = 60; /* default: 60 seconds */
             	const char *timeoutenv = getenv("CHGTIMEOUT");
             	if (timeoutenv)
             		sscanf(timeoutenv, "%u", &timeoutsec);
             		hgclient_t *hgc = hgc_open(opts->initsockname);
             		if (hgc) {
             			debugmsg("rename %s to %s", opts->initsockname,
-            					opts->sockname);
+            			         opts->sockname);
             			int r = rename(opts->initsockname, opts->sockname);
             			if (r != 0)
             				abortmsgerrno("cannot rename");
             	if (WIFEXITED(pst)) {
             		if (WEXITSTATUS(pst) == 0)
             			abortmsg("could not connect to cmdserver "
-            				 "(exited with status 0)");
+            			         "(exited with status 0)");
             		debugmsg("cmdserver exited with status %d", WEXITSTATUS(pst));
             		exit(WEXITSTATUS(pst));
             	} else if (WIFSIGNALED(pst)) {
             /* Connect to a cmdserver. Will start a new server on demand. */
             static hgclient_t *connectcmdserver(struct cmdserveropts *opts)
             {
-            	const char *sockname = opts->redirectsockname[0] ?
+            	const char *sockname =
-            		opts->redirectsockname : opts->sockname;
+            	    opts->redirectsockname[0] ? opts->redirectsockname : opts->sockname;
             	debugmsg("try connect to %s", sockname);
             	hgclient_t *hgc = hgc_open(sockname);
             	if (hgc)
             			unlink(*pinst + 7);
             		} else if (strncmp(*pinst, "redirect ", 9) == 0) {
             			int r = snprintf(opts->redirectsockname,
-            					 sizeof(opts->redirectsockname),
+            			                 sizeof(opts->redirectsockname), "%s",
-            					 "%s", *pinst + 9);
+            			                 *pinst + 9);
             			if (r < 0 || r >= (int)sizeof(opts->redirectsockname))
             				abortmsg("redirect path is too long (%d)", r);
             			needreconnect = 1;
              */
             static int isunsupported(int argc, const char *argv[])
             {
-            	enum {
+            	enum { SERVE = 1,
-            		SERVE = 1,
+            	       DAEMON = 2,
-            		DAEMON = 2,
+            	       SERVEDAEMON = SERVE | DAEMON,
-            		SERVEDAEMON = SERVE | DAEMON,
             	};
             	unsigned int state = 0;
             	int i;
             		if (i == 0 && strcmp("serve", argv[i]) == 0)
             			state |= SERVE;
             		else if (strcmp("-d", argv[i]) == 0 ||
-            			 strcmp("--daemon", argv[i]) == 0)
+            		         strcmp("--daemon", argv[i]) == 0)
             			state |= DAEMON;
             	}
             	return (state & SERVEDAEMON) == SERVEDAEMON;
             	if (getenv("CHGINTERNALMARK"))
             		abortmsg("chg started by chg detected.\n"
-            			 "Please make sure ${HG:-hg} is not a symlink or "
+            		         "Please make sure ${HG:-hg} is not a symlink or "
-            			 "wrapper to chg. Alternatively, set $CHGHG to the "
+            		         "wrapper to chg. Alternatively, set $CHGHG to the "
-            			 "path of real hg.");
+            		         "path of real hg.");
             	if (isunsupported(argc - 1, argv + 1))
             		execoriginalhg(argv);
             		hgc_close(hgc);
             		if (++retry > 10)
             			abortmsg("too many redirections.\n"
-            				 "Please make sure %s is not a wrapper which "
+            			         "Please make sure %s is not a wrapper which "
-            				 "changes sensitive environment variables "
+            			         "changes sensitive environment variables "
-            				 "before executing hg. If you have to use a "
+            			         "before executing hg. If you have to use a "
-            				 "wrapper, wrap chg instead of hg.",
+            			         "wrapper, wrap chg instead of hg.",
-            				 gethgcmd());
+            			         gethgcmd());
             	}
             	setupsignalhandler(hgc_peerpid(hgc), hgc_peerpgid(hgc));

contrib/chg/hgclient.c

0 +35 -36

              * GNU General Public License version 2 or any later version.
              */
-            #include <arpa/inet.h>  /* for ntohl(), htonl() */
+            #include <arpa/inet.h> /* for ntohl(), htonl() */
             #include <assert.h>
             #include <ctype.h>
             #include <errno.h>
             #include "procutil.h"
             #include "util.h"
-            enum {
+            enum { CAP_GETENCODING = 0x0001,
-            	CAP_GETENCODING = 0x0001,
+                   CAP_RUNCOMMAND = 0x0002,
-            	CAP_RUNCOMMAND = 0x0002,
+                   /* cHg extension: */
-            	/* cHg extension: */
+                   CAP_ATTACHIO = 0x0100,
-            	CAP_ATTACHIO = 0x0100,
+                   CAP_CHDIR = 0x0200,
-            	CAP_CHDIR = 0x0200,
+                   CAP_SETENV = 0x0800,
-            	CAP_SETENV = 0x0800,
+                   CAP_SETUMASK = 0x1000,
-            	CAP_SETUMASK = 0x1000,
+                   CAP_VALIDATE = 0x2000,
-            	CAP_VALIDATE = 0x2000,
+                   CAP_SETPROCNAME = 0x4000,
-            	CAP_SETPROCNAME = 0x4000,
             };
             typedef struct {
             } cappair_t;
             static const cappair_t captable[] = {
-            	{"getencoding", CAP_GETENCODING},
+                {"getencoding", CAP_GETENCODING},
-            	{"runcommand", CAP_RUNCOMMAND},
+                {"runcommand", CAP_RUNCOMMAND},
-            	{"attachio", CAP_ATTACHIO},
+                {"attachio", CAP_ATTACHIO},
-            	{"chdir", CAP_CHDIR},
+                {"chdir", CAP_CHDIR},
-            	{"setenv", CAP_SETENV},
+                {"setenv", CAP_SETENV},
-            	{"setumask", CAP_SETUMASK},
+                {"setumask", CAP_SETUMASK},
-            	{"validate", CAP_VALIDATE},
+                {"validate", CAP_VALIDATE},
-            	{"setprocname", CAP_SETPROCNAME},
+                {"setprocname", CAP_SETPROCNAME},
-            	{NULL, 0},  /* terminator */
+                {NULL, 0}, /* terminator */
             };
             typedef struct {
             	if (newsize <= ctx->maxdatasize)
             		return;
-            	newsize = defaultdatasize
+            	newsize = defaultdatasize *
-            		* ((newsize + defaultdatasize - 1) / defaultdatasize);
+            	          ((newsize + defaultdatasize - 1) / defaultdatasize);
             	ctx->data = reallocx(ctx->data, newsize);
             	ctx->maxdatasize = newsize;
             	debugmsg("enlarge context buffer to %zu", ctx->maxdatasize);
             	enlargecontext(&hgc->ctx, hgc->ctx.datasize);
             	if (isupper(hgc->ctx.ch) && hgc->ctx.ch != 'S')
-            		return;  /* assumes input request */
+            		return; /* assumes input request */
             	size_t cursize = 0;
             	while (cursize < hgc->ctx.datasize) {
             		rsize = recv(hgc->sockfd, hgc->ctx.data + cursize,
-            			     hgc->ctx.datasize - cursize, 0);
+            		             hgc->ctx.datasize - cursize, 0);
             		if (rsize < 1)
             			abortmsg("failed to read data block");
             		cursize += rsize;
             /* Build '\0'-separated list of args. argsize < 0 denotes that args are
              * terminated by NULL. */
             static void packcmdargs(context_t *ctx, const char *const args[],
-            			ssize_t argsize)
+                                    ssize_t argsize)
             {
             	ctx->datasize = 0;
             	const char *const *const end = (argsize >= 0) ? args + argsize : NULL;
             	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);
             		memcpy(ctx->data + ctx->datasize, *it, n);
             		ctx->datasize += n;
             	}
             	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 */
             	const char *s = ctx->data;
             	const char *e = ctx->data + ctx->datasize;
             	for (;;) {
-            		if (nargs + 1 >= maxnargs) {  /* including last NULL */
+            		if (nargs + 1 >= maxnargs) { /* including last NULL */
             			maxnargs += 256;
             			args = reallocx(args, maxnargs * sizeof(args[0]));
             		}
             {
             	context_t *ctx = &hgc->ctx;
             	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);
             	if (!args[0] || !args[1] || !args[2])
             	for (;;) {
             		readchannel(hgc);
             		context_t *ctx = &hgc->ctx;
-            		debugmsg("response read from channel %c, size %zu",
+            		debugmsg("response read from channel %c, size %zu", ctx->ch,
-            			 ctx->ch, ctx->datasize);
+            		         ctx->datasize);
             		switch (ctx->ch) {
             		case 'o':
             			fwrite(ctx->data, sizeof(ctx->data[0]), ctx->datasize,
             		default:
             			if (isupper(ctx->ch))
             				abortmsg("cannot handle response (ch = %c)",
-            					 ctx->ch);
+            				         ctx->ch);
             		}
             	}
             }
             static void updateprocname(hgclient_t *hgc)
             {
-            	int r = snprintf(hgc->ctx.data, hgc->ctx.maxdatasize,
+            	int r = snprintf(hgc->ctx.data, hgc->ctx.maxdatasize, "chg[worker/%d]",
-            			"chg[worker/%d]", (int)getpid());
+            	                 (int)getpid());
             	if (r < 0 || (size_t)r >= hgc->ctx.maxdatasize)
             		abortmsg("insufficient buffer to write procname (r = %d)", r);
             	hgc->ctx.datasize = (size_t)r;
             	static const int fds[3] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};
             	struct msghdr 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_iovlen = 1;
             	char fdbuf[CMSG_SPACE(sizeof(fds))];
              *           the last string is guaranteed to be NULL.
              */
             const char **hgc_validate(hgclient_t *hgc, const char *const args[],
-            			  size_t argsize)
+                                      size_t argsize)
             {
             	assert(hgc);
             	if (!(hgc->capflags & CAP_VALIDATE))

contrib/chg/hgclient.h

0 +2 -2

             pid_t hgc_peerpid(const hgclient_t *hgc);
             const char **hgc_validate(hgclient_t *hgc, const char *const args[],
-            			  size_t argsize);
+                                      size_t argsize);
             int hgc_runcommand(hgclient_t *hgc, const char *const args[], size_t argsize);
             void hgc_attachio(hgclient_t *hgc);
             void hgc_setenv(hgclient_t *hgc, const char *const envp[]);
-            #endif  /* HGCLIENT_H_ */
+            #endif /* HGCLIENT_H_ */

contrib/chg/procutil.c

0 +3 -3

             		goto error;
             	forwardsignal(sig);
-            	if (raise(sig) < 0)  /* resend to self */
+            	if (raise(sig) < 0) /* resend to self */
             		goto error;
             	if (sigaction(sig, &sa, &oldsa) < 0)
             		goto error;
             		close(pipefds[0]);
             		close(pipefds[1]);
-            		int r = execle("/bin/sh", "/bin/sh", "-c", pagercmd, NULL,
+            		int r =
-            				envp);
+            		    execle("/bin/sh", "/bin/sh", "-c", pagercmd, NULL, envp);
             		if (r < 0) {
             			abortmsgerrno("cannot start pager '%s'", pagercmd);
             		}

contrib/chg/util.c

0 +2 -1

             static int debugmsgenabled = 0;
             static double debugstart = 0;
-            static double now() {
+            static double now()
+            {
             	struct timeval t;
             	gettimeofday(&t, NULL);
             	return t.tv_usec / 1e6 + t.tv_sec;

contrib/chg/util.h

0 +1 -1

@@ -32,4 +32,4 b' void reallocx(void ptr, size_t size);'
32		32
33	int runshellcmd(const char cmd, const char envp[], const char *cwd);	33	int runshellcmd(const char cmd, const char envp[], const char *cwd);
34		34
35	#endif /* UTIL_H_ */	35	#endif /* UTIL_H_ */

contrib/clang-format-blacklist

0 0 -7

@@ -1,12 +1,5 b''
1	# Files that just need to be migrated to the formatter.	1	# Files that just need to be migrated to the formatter.
2	# Do not add new files here!	2	# Do not add new files here!
3	contrib/chg/chg.c
4	contrib/chg/hgclient.c
5	contrib/chg/hgclient.h
6	contrib/chg/procutil.c
7	contrib/chg/procutil.h
8	contrib/chg/util.c
9	contrib/chg/util.h
10	contrib/hgsh/hgsh.c	3	contrib/hgsh/hgsh.c
11	mercurial/cext/base85.c	4	mercurial/cext/base85.c
12	mercurial/cext/bdiff.c	5	mercurial/cext/bdiff.c

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages