Massive Cleanup

  * .clang-format
    - Started work on configuring clang-format options

  * .clang-tidy
    - Started work on configuring static analysis options

  * compile_commands.json
    - Hand-written compilation database to help with the clang tooling

  This is a first-pass refactor primarily targeting statements in branches
  or loops that weren't enclosed in braces to clearly delineate their scope.
  Additionally, some minor whitespace and naming changes were made, as well as
  normalizing the format of function definitions.
  There's still a LOT of work to be done for this project, but this is a good step
  towards making it easier to automatically catch and fix certain types of maintenance
  burdens and potential issues not covered by typical compiler warnings.

Author: newnix

.clang-format

@@ -0,0 +1,41 @@
+# vim: ft=yaml
+---
+## Supposedly supports C too, but there's no documented
+## support for setting a C standard like C11, so
+## the utility for C codebases may be somewhat limited.
+Language: Cpp
+BasedOnStyle: None
+IndentWidth: 2
+AccessModifierOffset: 0
+AlignAfterOpenBracket: Align
+AlignConsecutiveMacros: true
+AlignEscapedNewlines: Left
+AlignOperands: Align
+AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterReturnType: AllDefinitions
+AlwaysBreakBeforeMultilineStrings: false
+BinPackArguments: true
+BinPackParameters: true
+BreakBeforeBraces: Attach
+BreakBeforeTernaryOperators: true
+BreakStringLiterals: true
+ColumnLimit: 120
+DisableFormat: false
+IncludeBlocks: Regroup
+IncludeCategories:
+  - Regex: '^<(sys)/'
+    Priority: -3
+  - Regex: '^<([:alnum:]+/)'
+    Priority: -2
+  - Regex: '^<'
+    Priority: -1
+  - Regex: '^"'
+    Priority: 0
+IncludeIsMainRegex: '([_-]test)?$'

.clang-tidy

@@ -0,0 +1,28 @@
+# vim: ft=yaml
+## NOTE: Documentation is available online here:
+# https://clang.llvm.org/extra/clang-tidy/checks/list.html
+---
+Checks: -*,
+  bugprone-*,
+  clang-analyzer-*,
+  readability-*,
+  cert-*,
+  performance-*,
+  portability-*,
+  modernize-*,
+  concurrency-*,
+  llvm-libc-*,
+  misc-*,
+  -readability-avoid-const-params-in-decls,
+  -readability-isolate-declaration
+WarningsAsErrors: -*,
+  clang-analyzer-*,
+  readability-*,
+  bugprone-*,
+  modernize-*,
+  -readability-redundant-control-flow
+  -readability-else-after-return
+CheckOptions:
+  ## XXX: This is the default, but I want to be explicit with this check
+  - key: 'readability-braces-around-statements.ShortStatementLines'
+    value: 0

access.c

@@ -15,7 +15,8 @@
 #define	OTHER	0
 
 /* ingroupset -- determine whether gid lies in the user's set of groups */
-static Boolean ingroupset(int gid) {
+static Boolean
+ingroupset(int gid) {
 #ifdef NGROUPS
 	int i;
 	static int ngroups;
@@ -25,19 +26,23 @@ static Boolean ingroupset(int gid) {
 		initialized = TRUE;
 		ngroups = getgroups(NGROUPS, gidset);
 	}
-	for (i = 0; i < ngroups; i++)
-		if (gid == gidset[i])
+	for (i = 0; i < ngroups; i++) {
+		if (gid == gidset[i]) {
 			return TRUE;
+		}
+	}
 #endif
 	return FALSE;
 }
 
-static int testperm(struct stat *stat, int perm) {
+static int
+testperm(struct stat *stat, int perm) {
 	int mask;
-	static int uid, gid;
+	static uid_t uid, gid;
 	static Boolean initialized = FALSE;
-	if (perm == 0)
+	if (perm == 0) {
 		return 0;
+	}
 	if (!initialized) {
 		initialized = TRUE;
 		uid = geteuid();
@@ -54,31 +59,38 @@ static int testperm(struct stat *stat, int perm) {
 	return (stat->st_mode & mask) ? 0 : EACCES;
 }
 
-static int testfile(char *path, int perm, int type) {
+static int
+testfile(char *path, int perm, int type) {
 	struct stat st;
 #ifdef S_IFLNK
 	if (type == S_IFLNK) {
-		if (lstat(path, &st) == -1)
+		if (lstat(path, &st) == -1) {
 			return errno;
+		}
 	} else
 #endif
-		if (stat(path, &st) == -1)
+		if (stat(path, &st) == -1) {
 			return errno;
-	if (type != 0 && (st.st_mode & S_IFMT) != type)
+		}
+	if (type != 0 && (st.st_mode & S_IFMT) != type) {
 		return EACCES;		/* what is an appropriate return value? */
+	}
 	return testperm(&st, perm);
 }
 
-static char *pathcat(char *prefix, char *suffix) {
+static char
+*pathcat(char *prefix, char *suffix) {
 	char *s;
 	size_t plen, slen, len;
 	static char *pathbuf = NULL;
 	static size_t pathlen = 0;
 
-	if (*prefix == '\0')
+	if (*prefix == '\0') {
 		return suffix;
-	if (*suffix == '\0')
+	}
+	if (*suffix == '\0') {
 		return prefix;
+	}
 
 	plen = strlen(prefix);
 	slen = strlen(suffix);
@@ -90,8 +102,9 @@ static char *pathcat(char *prefix, char *suffix) {
 
 	memcpy(pathbuf, prefix, plen);
 	s = pathbuf + plen;
-	if (s[-1] != '/')
+	if (s[-1] != '/') {
 		*s++ = '/';
+	}
 	memcpy(s, suffix, slen + 1);
 	return pathbuf;
 }
@@ -106,7 +119,7 @@ static List
 
 	gcdisable();
 	esoptbegin(list, "$&access", usage);
-	while ((c = esopt("bcdefln:prswx1")) != EOF)
+	while ((c = esopt("bcdefln:prswx1")) != EOF) {
 		switch (c) {
 		case 'n':	suffix = getstr(esoptarg());	break;
 		case '1':	first = TRUE;			break;
@@ -131,15 +144,17 @@ static List
 			esoptend();
 			fail("$&access", "access -%c is not supported on this system", c);
 		}
+	}
 	list = esoptend();
 
 	for (lp = NULL; list != NULL; list = list->next) {
 		int error;
 		char *name;
 
 		name = getstr(list->term);
-		if (suffix != NULL)
+		if (suffix != NULL) {
 			name = pathcat(name, suffix);
+		}
 		error = testfile(name, perm, type);
 
 		if (first) {
@@ -151,32 +166,39 @@ static List
 					       NULL));
 				gcenable();
 				RefReturn(result);
-			} else if (error != ENOENT)
-				estatus = error;
-		} else
+			} else {
+				if (error != ENOENT) {
+					estatus = error;
+				}
+			}
+		} else {
 			lp = mklist(mkstr(error == 0 ? "0" : esstrerror(error)),
 				    lp);
+		}
 	}
 
 	if (first && exception) {
 		gcenable();
-		if (suffix)
+		if (suffix) {
 			fail("$&access", "%s: %s", suffix, esstrerror(estatus));
-		else
+		} else {
 			fail("$&access", "%s", esstrerror(estatus));
+		}
 	}
 
 	Ref(List *, result, reverse(lp));
 	gcenable();
 	RefReturn(result);
 }
 
-extern Dict *initprims_access(Dict *primdict) {
+extern Dict
+*initprims_access(Dict *primdict) {
 	primdict = dictput(primdict, STRING(access), (void *)prim_access);
 	return primdict;
 }
 
-extern char *checkexecutable(char *file) {
+extern char
+*checkexecutable(char *file) {
 	int err = testfile(file, EXEC, S_IFREG);
 	return err == 0 ? NULL : esstrerror(err);
 }

closure.c

@@ -9,7 +9,8 @@
 
 DefineTag(Closure, static);
 
-extern Closure *mkclosure(Tree *tree, Binding *binding) {
+extern Closure
+*mkclosure(Tree *tree, Binding *binding) {
 	gcdisable();
 	Ref(Closure *, closure, gcnew(Closure));
 	closure->tree = tree;
@@ -18,24 +19,28 @@ extern Closure *mkclosure(Tree *tree, Binding *binding) {
 	RefReturn(closure);
 }
 
-static void *ClosureCopy(void *op) {
+static void
+*ClosureCopy(void *op) {
 	void *np = gcnew(Closure);
 	memcpy(np, op, sizeof (Closure));
 	return np;
 }
 
-static size_t ClosureScan(void *p) {
+static size_t
+ClosureScan(void *p) {
 	Closure *closure = p;
 	closure->tree = forward(closure->tree);
 	closure->binding = forward(closure->binding);
 	return sizeof (Closure);
 }
 
 /* revtree -- destructively reverse a list stored in a tree */
-static Tree *revtree(Tree *tree) {
+static Tree
+*revtree(Tree *tree) {
 	Tree *prev, *next;
-	if (tree == NULL)
+	if (tree == NULL) {
 		return NULL;
+	}
 	prev = NULL;
 	do {
 		assert(tree->kind == nList);
@@ -54,10 +59,11 @@ typedef struct Chain {
 /* Internal initialization of the chain */
 static Chain *chain = NULL;
 
-static Binding *extract(Tree *tree, Binding *bindings) {
+static Binding
+*extract(Tree *tree, Binding *bindings) {
 	assert(gcisblocked());
 
-	/* 
+	/*
 	 * Tree layout:
 	 * Nodekind kind;
 	 * union { Tree *p; char *s; int i; } u[2];
@@ -94,16 +100,18 @@ static Binding *extract(Tree *tree, Binding *bindings) {
 								fail("$&parse", "bad count in $&nestedbinding: %d", count);
 								NOTREACHED;
 							}
-							if (i == count)
+							if (i == count) {
 								break;
+							}
 						}
 						term = mkterm(NULL, cp->closure);
 					} else {
 						fail("$&parse", "bad unquoted primitive in %%closure: $&%s", prim);
 						NOTREACHED;
 					}
-				} else
+				} else {
 					term = mkstr(word->u[0].s);
+				}
 				list = mklist(term, list);
 			}
 			bindings = mkbinding(name->u[0].s, list, bindings);
@@ -113,15 +121,17 @@ static Binding *extract(Tree *tree, Binding *bindings) {
 	return bindings;
 }
 
-extern Closure *extractbindings(Tree *tree0) {
+extern Closure
+*extractbindings(Tree *tree0) {
 	Chain me;
 	Tree *volatile tree = tree0;
 	Binding *volatile bindings = NULL;
 
 	gcdisable();
 
-	if (tree->kind == nList && tree->u[1].p == NULL)
-		tree = tree->u[0].p; 
+	if (tree->kind == nList && tree->u[1].p == NULL) {
+		tree = tree->u[0].p;
+	}
 
 	me.closure = mkclosure(NULL, NULL);
 	me.next = chain;
@@ -132,8 +142,9 @@ extern Closure *extractbindings(Tree *tree0) {
 		while (tree->kind == nClosure) {
 			bindings = extract(tree->u[0].p, bindings);
 			tree = tree->u[1].p;
-			if (tree->kind == nList && tree->u[1].p == NULL)
-				tree = tree->u[0].p; 
+			if (tree->kind == nList && tree->u[1].p == NULL) {
+				tree = tree->u[0].p;
+			}
 		}
 
 	CatchException (e)
@@ -159,7 +170,8 @@ extern Closure *extractbindings(Tree *tree0) {
 
 DefineTag(Binding, static);
 
-extern Binding *mkbinding(char *name, List *defn, Binding *next) {
+extern Binding
+*mkbinding(char *name, List *defn, Binding *next) {
 	assert(next == NULL || next->name != NULL);
 	validatevar(name);
 	gcdisable();
@@ -171,10 +183,11 @@ extern Binding *mkbinding(char *name, List *defn, Binding *next) {
 	RefReturn(binding);
 }
 
-extern Binding *reversebindings(Binding *binding) {
-	if (binding == NULL)
+extern Binding
+*reversebindings(Binding *binding) {
+	if (binding == NULL) {
 		return NULL;
-	else {
+	} else {
 		Binding *prev, *next;
 		prev = NULL;
 		do {
@@ -186,13 +199,15 @@ extern Binding *reversebindings(Binding *binding) {
 	}
 }
 
-static void *BindingCopy(void *op) {
+static void
+*BindingCopy(void *op) {
 	void *np = gcnew(Binding);
 	memcpy(np, op, sizeof (Binding));
 	return np;
 }
 
-static size_t BindingScan(void *p) {
+static size_t
+BindingScan(void *p) {
 	Binding *binding = p;
 	binding->name = forward(binding->name);
 	binding->defn = forward(binding->defn);