Merge branch 'clang_format_prep_3'

17 files changed, 127 insertions, 111 deletions

diff --git a/src/lib/cc/compat_compiler.h b/src/lib/cc/compat_compiler.h
index 1bb8c54a0c..e4b0ea61ca 100644
--- a/src/lib/cc/compat_compiler.h
+++ b/src/lib/cc/compat_compiler.h
@@ -25,11 +25,11 @@
 #endif /* defined(__has_feature) */
 
 #ifndef NULL_REP_IS_ZERO_BYTES
-#error "It seems your platform does not represent NULL as zero. We can't cope."
+#error "Your platform does not represent NULL as zero. We can't cope."
 #endif
 
 #ifndef DOUBLE_0_REP_IS_ZERO_BYTES
-#error "It seems your platform does not represent 0.0 as zeros. We can't cope."
+#error "Your platform does not represent 0.0 as zeros. We can't cope."
 #endif
 
 #if 'a'!=97 || 'z'!=122 || 'A'!=65 || ' '!=32
diff --git a/src/lib/cc/torint.h b/src/lib/cc/torint.h
index cef1482bdc..af7a90431c 100644
--- a/src/lib/cc/torint.h
+++ b/src/lib/cc/torint.h
@@ -49,7 +49,7 @@ typedef int32_t ssize_t;
  * aren't 2's complement, and you don't define LONG_MAX, then you're so
  * bizarre that I want nothing to do with you. */
 #ifndef USING_TWOS_COMPLEMENT
-#error "Seems that your platform doesn't use 2's complement arithmetic. Argh."
+#error "Your platform doesn't use 2's complement arithmetic."
 #endif
 
 #ifndef TIME_MAX
@@ -126,12 +126,11 @@ typedef int32_t ssize_t;
 #define SIZE_T_CEILING  ((size_t)(SSIZE_MAX-16))
 
 #if SIZEOF_INT > SIZEOF_VOID_P
-#error "sizeof(int) > sizeof(void *) - Tor cannot be built on this platform!"
+#error "sizeof(int) > sizeof(void *) - Can't build Tor here."
 #endif
 
 #if SIZEOF_UNSIGNED_INT > SIZEOF_VOID_P
-#error "sizeof(unsigned int) > sizeof(void *) - Tor cannot be built on this \
-platform!"
+#error "sizeof(unsigned int) > sizeof(void *) - Can't build Tor here."
 #endif
 
 #endif /* !defined(TOR_TORINT_H) */
diff --git a/src/lib/conf/conftypes.h b/src/lib/conf/conftypes.h
index ebc2736aaa..081ebf397f 100644
--- a/src/lib/conf/conftypes.h
+++ b/src/lib/conf/conftypes.h
@@ -260,6 +260,7 @@ typedef struct config_deprecation_t {
   const char *why_deprecated;
 } config_deprecation_t;
 
+#ifndef COCCI
 /**
  * Handy macro for declaring "In the config file or on the command line, you
  * can abbreviate <b>tok</b>s as <b>tok</b>". Used inside an array of
@@ -268,7 +269,8 @@ typedef struct config_deprecation_t {
  * For example, to declare "NumCpu" as an abbreviation for "NumCPUs",
  * you can say PLURAL(NumCpu).
  **/
-#define PLURAL(tok) { #tok, #tok "s", 0, 0 }
+#define PLURAL(tok) { (#tok), (#tok "s"), 0, 0 }
+#endif /* !defined(COCCI) */
 
 /**
  * Validation function: verify whether a configuation object is well-formed
diff --git a/src/lib/confmgt/unitparse.c b/src/lib/confmgt/unitparse.c
index 52c0eabb69..995cb93834 100644
--- a/src/lib/confmgt/unitparse.c
+++ b/src/lib/confmgt/unitparse.c
@@ -21,6 +21,7 @@
 
 /** Table to map the names of memory units to the number of bytes they
  * contain. */
+// clang-format off
 const struct unit_table_t memory_units[] = {
   { "",          1 },
   { "b",         1<< 0 },
@@ -65,9 +66,11 @@ const struct unit_table_t memory_units[] = {
   { "tbit",      UINT64_C(1)<<37 },
   { NULL, 0 },
 };
+// clang-format on
 
 /** Table to map the names of time units to the number of seconds they
  * contain. */
+// clang-format off
 const struct unit_table_t time_units[] = {
   { "",         1 },
   { "second",   1 },
@@ -84,9 +87,11 @@ const struct unit_table_t time_units[] = {
   { "months",   2629728, },
   { NULL, 0 },
 };
+// clang-format on
 
 /** Table to map the names of time units to the number of milliseconds
  * they contain. */
+// clang-format off
 const struct unit_table_t time_msec_units[] = {
   { "",         1 },
   { "msec",     1 },
@@ -104,6 +109,7 @@ const struct unit_table_t time_msec_units[] = {
   { "weeks",    7*24*60*60*1000 },
   { NULL, 0 },
 };
+// clang-format on
 
 /** Parse a string <b>val</b> containing a number, zero or more
  * spaces, and an optional unit string.  If the unit appears in the
diff --git a/src/lib/container/map.c b/src/lib/container/map.c
index c3fb0b5c8a..7db84313ea 100644
--- a/src/lib/container/map.c
+++ b/src/lib/container/map.c
@@ -85,21 +85,21 @@ digest256map_entry_hash(const digest256map_entry_t *a)
 }
 
 HT_PROTOTYPE(strmap_impl, strmap_entry_t, node, strmap_entry_hash,
-             strmap_entries_eq)
+             strmap_entries_eq);
 HT_GENERATE2(strmap_impl, strmap_entry_t, node, strmap_entry_hash,
-             strmap_entries_eq, 0.6, tor_reallocarray_, tor_free_)
+             strmap_entries_eq, 0.6, tor_reallocarray_, tor_free_);
 
 HT_PROTOTYPE(digestmap_impl, digestmap_entry_t, node, digestmap_entry_hash,
-             digestmap_entries_eq)
+             digestmap_entries_eq);
 HT_GENERATE2(digestmap_impl, digestmap_entry_t, node, digestmap_entry_hash,
-             digestmap_entries_eq, 0.6, tor_reallocarray_, tor_free_)
+             digestmap_entries_eq, 0.6, tor_reallocarray_, tor_free_);
 
 HT_PROTOTYPE(digest256map_impl, digest256map_entry_t, node,
              digest256map_entry_hash,
-             digest256map_entries_eq)
+             digest256map_entries_eq);
 HT_GENERATE2(digest256map_impl, digest256map_entry_t, node,
              digest256map_entry_hash,
-             digest256map_entries_eq, 0.6, tor_reallocarray_, tor_free_)
+             digest256map_entries_eq, 0.6, tor_reallocarray_, tor_free_);
 
 #define strmap_entry_free(ent) \
   FREE_AND_NULL(strmap_entry_t, strmap_entry_free_, (ent))
diff --git a/src/lib/container/map.h b/src/lib/container/map.h
index 989ecfad80..dbc1967247 100644
--- a/src/lib/container/map.h
+++ b/src/lib/container/map.h
@@ -19,29 +19,29 @@
 
 #define DECLARE_MAP_FNS(mapname_t, keytype, prefix)                     \
   typedef struct mapname_t mapname_t;                                   \
-  typedef struct prefix##entry_t *prefix##iter_t;                       \
-  MOCK_DECL(mapname_t*, prefix##new, (void));                           \
-  void* prefix##set(mapname_t *map, keytype key, void *val);            \
-  void* prefix##get(const mapname_t *map, keytype key);                 \
-  void* prefix##remove(mapname_t *map, keytype key);                    \
-  MOCK_DECL(void, prefix##free_, (mapname_t *map, void (*free_val)(void*))); \
-  int prefix##isempty(const mapname_t *map);                            \
-  int prefix##size(const mapname_t *map);                               \
-  prefix##iter_t *prefix##iter_init(mapname_t *map);                    \
-  prefix##iter_t *prefix##iter_next(mapname_t *map, prefix##iter_t *iter); \
-  prefix##iter_t *prefix##iter_next_rmv(mapname_t *map,                 \
-                                        prefix##iter_t *iter);          \
-  void prefix##iter_get(prefix##iter_t *iter, keytype *keyp, void **valp); \
-  int prefix##iter_done(prefix##iter_t *iter);                          \
-  void prefix##assert_ok(const mapname_t *map)
+  typedef struct prefix##_entry_t *prefix##_iter_t;                       \
+  MOCK_DECL(mapname_t*, prefix##_new, (void));                           \
+  void* prefix##_set(mapname_t *map, keytype key, void *val);            \
+  void* prefix##_get(const mapname_t *map, keytype key);                 \
+  void* prefix##_remove(mapname_t *map, keytype key);                    \
+  MOCK_DECL(void, prefix##_free_, (mapname_t *map, void (*free_val)(void*))); \
+  int prefix##_isempty(const mapname_t *map);                            \
+  int prefix##_size(const mapname_t *map);                               \
+  prefix##_iter_t *prefix##_iter_init(mapname_t *map);                    \
+  prefix##_iter_t *prefix##_iter_next(mapname_t *map, prefix##_iter_t *iter); \
+  prefix##_iter_t *prefix##_iter_next_rmv(mapname_t *map,                 \
+                                        prefix##_iter_t *iter);          \
+  void prefix##_iter_get(prefix##_iter_t *iter, keytype *keyp, void **valp); \
+  int prefix##_iter_done(prefix##_iter_t *iter);                          \
+  void prefix##_assert_ok(const mapname_t *map)
 
 /* Map from const char * to void *. Implemented with a hash table. */
-DECLARE_MAP_FNS(strmap_t, const char *, strmap_);
+DECLARE_MAP_FNS(strmap_t, const char *, strmap);
 /* Map from const char[DIGEST_LEN] to void *. Implemented with a hash table. */
-DECLARE_MAP_FNS(digestmap_t, const char *, digestmap_);
+DECLARE_MAP_FNS(digestmap_t, const char *, digestmap);
 /* Map from const uint8_t[DIGEST256_LEN] to void *. Implemented with a hash
  * table. */
-DECLARE_MAP_FNS(digest256map_t, const uint8_t *, digest256map_);
+DECLARE_MAP_FNS(digest256map_t, const uint8_t *, digest256map);
 
 #define MAP_FREE_AND_NULL(mapname_t, map, fn)     \
   do {                                          \
@@ -56,12 +56,12 @@ DECLARE_MAP_FNS(digest256map_t, const uint8_t *, digest256map_);
 #undef DECLARE_MAP_FNS
 
 /** Iterates over the key-value pairs in a map <b>map</b> in order.
- * <b>prefix</b> is as for DECLARE_MAP_FNS (i.e., strmap_ or digestmap_).
+ * <b>prefix</b> is as for DECLARE_MAP_FNS (i.e., strmap or digestmap).
  * The map's keys and values are of type keytype and valtype respectively;
  * each iteration assigns them to keyvar and valvar.
  *
  * Example use:
- *   MAP_FOREACH(digestmap_, m, const char *, k, routerinfo_t *, r) {
+ *   MAP_FOREACH(digestmap, m, const char *, k, routerinfo_t *, r) {
  *     // use k and r
  *   } MAP_FOREACH_END.
  */
@@ -81,21 +81,21 @@ DECLARE_MAP_FNS(digest256map_t, const uint8_t *, digest256map_);
  */
 #define MAP_FOREACH(prefix, map, keytype, keyvar, valtype, valvar)      \
   STMT_BEGIN                                                            \
-    prefix##iter_t *keyvar##_iter;                                      \
-    for (keyvar##_iter = prefix##iter_init(map);                        \
-         !prefix##iter_done(keyvar##_iter);                             \
-         keyvar##_iter = prefix##iter_next(map, keyvar##_iter)) {       \
+    prefix##_iter_t *keyvar##_iter;                                      \
+    for (keyvar##_iter = prefix##_iter_init(map);                        \
+         !prefix##_iter_done(keyvar##_iter);                             \
+         keyvar##_iter = prefix##_iter_next(map, keyvar##_iter)) {       \
       keytype keyvar;                                                   \
       void *valvar##_voidp;                                             \
       valtype valvar;                                                   \
-      prefix##iter_get(keyvar##_iter, &keyvar, &valvar##_voidp);        \
+      prefix##_iter_get(keyvar##_iter, &keyvar, &valvar##_voidp);        \
       valvar = valvar##_voidp;
 
 /** As MAP_FOREACH, except allows members to be removed from the map
  * during the iteration via MAP_DEL_CURRENT.  Example use:
  *
  * Example use:
- *   MAP_FOREACH(digestmap_, m, const char *, k, routerinfo_t *, r) {
+ *   MAP_FOREACH(digestmap, m, const char *, k, routerinfo_t *, r) {
  *      if (is_very_old(r))
  *       MAP_DEL_CURRENT(k);
  *   } MAP_FOREACH_END.
@@ -121,18 +121,18 @@ DECLARE_MAP_FNS(digest256map_t, const uint8_t *, digest256map_);
  */
 #define MAP_FOREACH_MODIFY(prefix, map, keytype, keyvar, valtype, valvar) \
   STMT_BEGIN                                                            \
-    prefix##iter_t *keyvar##_iter;                                      \
+    prefix##_iter_t *keyvar##_iter;                                      \
     int keyvar##_del=0;                                                 \
-    for (keyvar##_iter = prefix##iter_init(map);                        \
-         !prefix##iter_done(keyvar##_iter);                             \
+    for (keyvar##_iter = prefix##_iter_init(map);                        \
+         !prefix##_iter_done(keyvar##_iter);                             \
          keyvar##_iter = keyvar##_del ?                                 \
-           prefix##iter_next_rmv(map, keyvar##_iter) :                  \
-           prefix##iter_next(map, keyvar##_iter)) {                     \
+           prefix##_iter_next_rmv(map, keyvar##_iter) :                  \
+           prefix##_iter_next(map, keyvar##_iter)) {                     \
       keytype keyvar;                                                   \
       void *valvar##_voidp;                                             \
       valtype valvar;                                                   \
       keyvar##_del=0;                                                   \
-      prefix##iter_get(keyvar##_iter, &keyvar, &valvar##_voidp);        \
+      prefix##_iter_get(keyvar##_iter, &keyvar, &valvar##_voidp);        \
       valvar = valvar##_voidp;
 
 /** Used with MAP_FOREACH_MODIFY to remove the currently-iterated-upon
@@ -152,7 +152,7 @@ DECLARE_MAP_FNS(digest256map_t, const uint8_t *, digest256map_);
  *   } DIGESTMAP_FOREACH_END.
  */
 #define DIGESTMAP_FOREACH(map, keyvar, valtype, valvar)                 \
-  MAP_FOREACH(digestmap_, map, const char *, keyvar, valtype, valvar)
+  MAP_FOREACH(digestmap, map, const char *, keyvar, valtype, valvar)
 
 /** As MAP_FOREACH_MODIFY, but does not require declaration of prefix or
  * keytype.
@@ -163,21 +163,21 @@ DECLARE_MAP_FNS(digest256map_t, const uint8_t *, digest256map_);
  *   } DIGESTMAP_FOREACH_END.
  */
 #define DIGESTMAP_FOREACH_MODIFY(map, keyvar, valtype, valvar)          \
-  MAP_FOREACH_MODIFY(digestmap_, map, const char *, keyvar, valtype, valvar)
+  MAP_FOREACH_MODIFY(digestmap, map, const char *, keyvar, valtype, valvar)
 /** Used to end a DIGESTMAP_FOREACH() block. */
 #define DIGESTMAP_FOREACH_END MAP_FOREACH_END
 
 #define DIGEST256MAP_FOREACH(map, keyvar, valtype, valvar)               \
-  MAP_FOREACH(digest256map_, map, const uint8_t *, keyvar, valtype, valvar)
+  MAP_FOREACH(digest256map, map, const uint8_t *, keyvar, valtype, valvar)
 #define DIGEST256MAP_FOREACH_MODIFY(map, keyvar, valtype, valvar)       \
-  MAP_FOREACH_MODIFY(digest256map_, map, const uint8_t *,               \
+  MAP_FOREACH_MODIFY(digest256map, map, const uint8_t *,               \
                      keyvar, valtype, valvar)
 #define DIGEST256MAP_FOREACH_END MAP_FOREACH_END
 
 #define STRMAP_FOREACH(map, keyvar, valtype, valvar)                 \
-  MAP_FOREACH(strmap_, map, const char *, keyvar, valtype, valvar)
+  MAP_FOREACH(strmap, map, const char *, keyvar, valtype, valvar)
 #define STRMAP_FOREACH_MODIFY(map, keyvar, valtype, valvar)          \
-  MAP_FOREACH_MODIFY(strmap_, map, const char *, keyvar, valtype, valvar)
+  MAP_FOREACH_MODIFY(strmap, map, const char *, keyvar, valtype, valvar)
 #define STRMAP_FOREACH_END MAP_FOREACH_END
 
 void* strmap_set_lc(strmap_t *map, const char *key, void *val);
@@ -186,66 +186,66 @@ void* strmap_remove_lc(strmap_t *map, const char *key);
 
 #define DECLARE_TYPED_DIGESTMAP_FNS(prefix, mapname_t, valtype)           \
   typedef struct mapname_t mapname_t;                                   \
-  typedef struct prefix##iter_t *prefix##iter_t;                        \
+  typedef struct prefix##_iter_t *prefix##_iter_t;                        \
   ATTR_UNUSED static inline mapname_t*                                  \
-  prefix##new(void)                                                     \
+  prefix##_new(void)                                                     \
   {                                                                     \
     return (mapname_t*)digestmap_new();                                 \
   }                                                                     \
   ATTR_UNUSED static inline digestmap_t*                                \
-  prefix##to_digestmap(mapname_t *map)                                  \
+  prefix##_to_digestmap(mapname_t *map)                                  \
   {                                                                     \
     return (digestmap_t*)map;                                           \
   }                                                                     \
   ATTR_UNUSED static inline valtype*                                    \
-  prefix##get(mapname_t *map, const char *key)                          \
+  prefix##_get(mapname_t *map, const char *key)                          \
   {                                                                     \
     return (valtype*)digestmap_get((digestmap_t*)map, key);             \
   }                                                                     \
   ATTR_UNUSED static inline valtype*                                    \
-  prefix##set(mapname_t *map, const char *key, valtype *val)            \
+  prefix##_set(mapname_t *map, const char *key, valtype *val)            \
   {                                                                     \
     return (valtype*)digestmap_set((digestmap_t*)map, key, val);        \
   }                                                                     \
   ATTR_UNUSED static inline valtype*                                    \
-  prefix##remove(mapname_t *map, const char *key)                       \
+  prefix##_remove(mapname_t *map, const char *key)                       \
   {                                                                     \
     return (valtype*)digestmap_remove((digestmap_t*)map, key);          \
   }                                                                     \
   ATTR_UNUSED static inline void                                        \
-  prefix##f##ree_(mapname_t *map, void (*free_val)(void*))              \
+  prefix##_f##ree_(mapname_t *map, void (*free_val)(void*))              \
   {                                                                     \
     digestmap_free_((digestmap_t*)map, free_val);                       \
   }                                                                     \
   ATTR_UNUSED static inline int                                         \
-  prefix##isempty(mapname_t *map)                                       \
+  prefix##_isempty(mapname_t *map)                                       \
   {                                                                     \
     return digestmap_isempty((digestmap_t*)map);                        \
   }                                                                     \
   ATTR_UNUSED static inline int                                         \
-  prefix##size(mapname_t *map)                                          \
+  prefix##_size(mapname_t *map)                                          \
   {                                                                     \
     return digestmap_size((digestmap_t*)map);                           \
   }                                                                     \
   ATTR_UNUSED static inline                                             \
-  prefix##iter_t *prefix##iter_init(mapname_t *map)                     \
+  prefix##_iter_t *prefix##_iter_init(mapname_t *map)                     \
   {                                                                     \
-    return (prefix##iter_t*) digestmap_iter_init((digestmap_t*)map);    \
+    return (prefix##_iter_t*) digestmap_iter_init((digestmap_t*)map);    \
   }                                                                     \
   ATTR_UNUSED static inline                                             \
-  prefix##iter_t *prefix##iter_next(mapname_t *map, prefix##iter_t *iter) \
+  prefix##_iter_t *prefix##_iter_next(mapname_t *map, prefix##_iter_t *iter) \
   {                                                                     \
-    return (prefix##iter_t*) digestmap_iter_next(                       \
+    return (prefix##_iter_t*) digestmap_iter_next(                       \
                        (digestmap_t*)map, (digestmap_iter_t*)iter);     \
   }                                                                     \
-  ATTR_UNUSED static inline prefix##iter_t*                             \
-  prefix##iter_next_rmv(mapname_t *map, prefix##iter_t *iter)           \
+  ATTR_UNUSED static inline prefix##_iter_t*                             \
+  prefix##_iter_next_rmv(mapname_t *map, prefix##_iter_t *iter)           \
   {                                                                     \
-    return (prefix##iter_t*) digestmap_iter_next_rmv(                   \
+    return (prefix##_iter_t*) digestmap_iter_next_rmv(                   \
                        (digestmap_t*)map, (digestmap_iter_t*)iter);     \
   }                                                                     \
   ATTR_UNUSED static inline void                                        \
-  prefix##iter_get(prefix##iter_t *iter,                                \
+  prefix##_iter_get(prefix##_iter_t *iter,                                \
                    const char **keyp,                                   \
                    valtype **valp)                                      \
   {                                                                     \
@@ -254,7 +254,7 @@ void* strmap_remove_lc(strmap_t *map, const char *key);
     *valp = v;                                                          \
   }                                                                     \
   ATTR_UNUSED static inline int                                         \
-  prefix##iter_done(prefix##iter_t *iter)                               \
+  prefix##_iter_done(prefix##_iter_t *iter)                               \
   {                                                                     \
     return digestmap_iter_done((digestmap_iter_t*)iter);                \
   }
diff --git a/src/lib/container/namemap.c b/src/lib/container/namemap.c
index 28695ee3a1..e286cad947 100644
--- a/src/lib/container/namemap.c
+++ b/src/lib/container/namemap.c
@@ -35,9 +35,9 @@ mapped_name_hash(const mapped_name_t *a)
 }
 
 HT_PROTOTYPE(namemap_ht, mapped_name_t, node, mapped_name_hash,
-             mapped_name_eq)
+             mapped_name_eq);
 HT_GENERATE2(namemap_ht, mapped_name_t, node, mapped_name_hash,
-             mapped_name_eq, 0.6, tor_reallocarray_, tor_free_)
+             mapped_name_eq, 0.6, tor_reallocarray_, tor_free_);
 
 /** Set up an uninitialized <b>map</b>. */
 void
diff --git a/src/lib/ctime/di_ops.c b/src/lib/ctime/di_ops.c
index e1ac0943fb..d57d286990 100644
--- a/src/lib/ctime/di_ops.c
+++ b/src/lib/ctime/di_ops.c
@@ -72,10 +72,10 @@ tor_memcmp(const void *a, const void *b, size_t len)
      * actually implementation-defined in standard C.  So how do we
      * get away with assuming it?  Easy.  We check.) */
 #if ((-60 >> 8) != -1)
-#error "According to cpp, right-shift doesn't perform sign-extension."
+#error "cpp says right-shift doesn't perform sign-extension."
 #endif
 #ifndef RSHIFT_DOES_SIGN_EXTEND
-#error "According to configure, right-shift doesn't perform sign-extension."
+#error "configure says right-shift doesn't perform sign-extension."
 #endif
 
     /* If v1 == v2, equal_p is ~0, so this will leave retval
diff --git a/src/lib/log/log.c b/src/lib/log/log.c
index 75f8f79da2..9ebe7350b2 100644
--- a/src/lib/log/log.c
+++ b/src/lib/log/log.c
@@ -523,7 +523,7 @@ logfile_deliver(logfile_t *lf, const char *buf, size_t msg_len,
      * pass them, and some very old ones do not detect overflow so well.
      * Regrettably, they call their maximum line length MAXLINE. */
 #if MAXLINE < 64
-#warning "MAXLINE is a very low number; it might not be from syslog.h."
+#warning "MAXLINE is very low; it might not be from syslog.h."
 #endif
     char *m = msg_after_prefix;
     if (msg_len >= MAXLINE)
diff --git a/src/lib/log/util_bug.c b/src/lib/log/util_bug.c
index de44d30e4e..83045ebb90 100644
--- a/src/lib/log/util_bug.c
+++ b/src/lib/log/util_bug.c
@@ -71,7 +71,6 @@ tor_set_failed_assertion_callback(void (*fn)(void))
 
 /** Helper for tor_assert: report the assertion failure. */
 void
-CHECK_PRINTF(5, 6)
 tor_assertion_failed_(const char *fname, unsigned int line,
                       const char *func, const char *expr,
                       const char *fmt, ...)
@@ -104,7 +103,6 @@ tor_assertion_failed_(const char *fname, unsigned int line,
 
 /** Helper for tor_assert_nonfatal: report the assertion failure. */
 void
-CHECK_PRINTF(6, 7)
 tor_bug_occurred_(const char *fname, unsigned int line,
                   const char *func, const char *expr,
                   int once, const char *fmt, ...)
diff --git a/src/lib/malloc/map_anon.c b/src/lib/malloc/map_anon.c
index 1926b61f07..628966012a 100644
--- a/src/lib/malloc/map_anon.c
+++ b/src/lib/malloc/map_anon.c
@@ -78,7 +78,7 @@
 #endif /* defined(HAVE_MINHERIT) || ... */
 
 #if defined(HAVE_MINHERIT) && !defined(FLAG_ZERO) && !defined(FLAG_NOINHERIT)
-#warning "minherit() is defined, but we couldn't find the right flag for it."
+#warning "minherit() is defined, but FLAG_ZERO/NOINHERIT are not."
 #warning "This is probably a bug in Tor's support for this platform."
 #endif
 
diff --git a/src/lib/math/prob_distr.c b/src/lib/math/prob_distr.c
index 548d256023..31d485120e 100644
--- a/src/lib/math/prob_distr.c
+++ b/src/lib/math/prob_distr.c
@@ -1284,15 +1284,16 @@ sample_genpareto_locscale(uint32_t s, double p0, double mu, double sigma,
 /**
  * Deterministically sample from the geometric distribution with
  * per-trial success probability p.
- *
+ **/
+// clang-format off
+/*
  * XXX Quantify the error (KL divergence?) of this
  * ceiling-of-exponential sampler from a true geometric distribution,
  * which we could get by rejection sampling.  Relevant papers:
  *
  *      John F. Monahan, `Accuracy in Random Number Generation',
  *      Mathematics of Computation 45(172), October 1984, pp. 559--568.
-*https://pdfs.semanticscholar.org/aca6/74b96da1df77b2224e8cfc5dd6d61a471632.pdf
- *
+https://pdfs.semanticscholar.org/aca6/74b96da1df77b2224e8cfc5dd6d61a471632.pdf
  *      Karl Bringmann and Tobias Friedrich, `Exact and Efficient
  *      Generation of Geometric Random Variates and Random Graphs', in
  *      Proceedings of the 40th International Colloaquium on Automata,
@@ -1301,6 +1302,7 @@ sample_genpareto_locscale(uint32_t s, double p0, double mu, double sigma,
  *      https://doi.org/10.1007/978-3-642-39206-1_23
  *      https://people.mpi-inf.mpg.de/~kbringma/paper/2013ICALP-1.pdf
  */
+// clang-format on
 static double
 sample_geometric(uint32_t s, double p0, double p)
 {
diff --git a/src/lib/memarea/memarea.c b/src/lib/memarea/memarea.c
index d677c364a4..4d26c20eeb 100644
--- a/src/lib/memarea/memarea.c
+++ b/src/lib/memarea/memarea.c
@@ -39,7 +39,7 @@
 #elif MEMAREA_ALIGN == 8
 #define MEMAREA_ALIGN_MASK ((uintptr_t)7)
 #else
-#error "void* is neither 4 nor 8 bytes long. I don't know how to align stuff."
+#error "void* is neither 4 nor 8 bytes long."
 #endif /* MEMAREA_ALIGN == 4 || ... */
 
 #if defined(__GNUC__) && defined(FLEXIBLE_ARRAY_MEMBER)
diff --git a/src/lib/net/address.c b/src/lib/net/address.c
index ac4350b8fe..e968d8a7f7 100644
--- a/src/lib/net/address.c
+++ b/src/lib/net/address.c
@@ -97,7 +97,7 @@
  * work correctly. Bail out here if we've found a platform where AF_UNSPEC
  * isn't 0. */
 #if AF_UNSPEC != 0
-#error We rely on AF_UNSPEC being 0. Let us know about your platform, please!
+#error "We rely on AF_UNSPEC being 0. Yours isn't. Please tell us more!"
 #endif
 CTASSERT(AF_UNSPEC == 0);
 
diff --git a/src/lib/net/resolve.c b/src/lib/net/resolve.c
index df079d5db3..68a8c01ef4 100644
--- a/src/lib/net/resolve.c
+++ b/src/lib/net/resolve.c
@@ -372,11 +372,11 @@ static HT_HEAD(getaddrinfo_cache, cached_getaddrinfo_item_t)
 
 HT_PROTOTYPE(getaddrinfo_cache, cached_getaddrinfo_item_t, node,
              cached_getaddrinfo_item_hash,
-             cached_getaddrinfo_items_eq)
+             cached_getaddrinfo_items_eq);
 HT_GENERATE2(getaddrinfo_cache, cached_getaddrinfo_item_t, node,
              cached_getaddrinfo_item_hash,
              cached_getaddrinfo_items_eq,
-             0.6, tor_reallocarray_, tor_free_)
+             0.6, tor_reallocarray_, tor_free_);
 
 /** If true, don't try to cache getaddrinfo results. */
 static int sandbox_getaddrinfo_cache_disabled = 0;
diff --git a/src/lib/osinfo/uname.c b/src/lib/osinfo/uname.c
index ac99726f51..800acdddb6 100644
--- a/src/lib/osinfo/uname.c
+++ b/src/lib/osinfo/uname.c
@@ -27,6 +27,40 @@ static char uname_result[256];
 /** True iff uname_result is set. */
 static int uname_result_is_set = 0;
 
+#ifdef _WIN32
+/** Table to map claimed windows versions into human-readable windows
+ * versions. */
+static struct {
+  unsigned major;
+  unsigned minor;
+  const char *client_version;
+  const char *server_version;
+} win_version_table[] = {
+  /* This table must be sorted in descending order.
+   * Sources:
+   *   https://en.wikipedia.org/wiki/List_of_Microsoft_Windows_versions
+   *   https://docs.microsoft.com/en-us/windows/desktop/api/winnt/
+   *     ns-winnt-_osversioninfoexa#remarks
+   */
+   /* Windows Server 2019 is indistinguishable from Windows Server 2016
+    * using GetVersionEx().
+   { 10,  0, NULL,                        "Windows Server 2019" }, */
+   // clang-format off
+   { 10,  0, "Windows 10",                "Windows Server 2016" },
+   {  6,  3, "Windows 8.1",               "Windows Server 2012 R2" },
+   {  6,  2, "Windows 8",                 "Windows Server 2012" },
+   {  6,  1, "Windows 7",                 "Windows Server 2008 R2" },
+   {  6,  0, "Windows Vista",             "Windows Server 2008" },
+   {  5,  2, "Windows XP Professional",   "Windows Server 2003" },
+   /* Windows XP did not have a server version, but we need something here */
+   {  5,  1, "Windows XP",                "Windows XP Server" },
+   {  5,  0, "Windows 2000 Professional", "Windows 2000 Server" },
+   /* Earlier versions are not supported by GetVersionEx(). */
+   {  0,  0, NULL,                        NULL }
+   // clang-format on
+};
+#endif
+
 /** Return a pointer to a description of our platform.
  */
 MOCK_IMPL(const char *,
@@ -49,31 +83,6 @@ get_uname,(void))
         int is_client = 0;
         int is_server = 0;
         const char *plat = NULL;
-        static struct {
-          unsigned major; unsigned minor;
-          const char *client_version; const char *server_version;
-        } win_version_table[] = {
-    /* This table must be sorted in descending order.
-     * Sources:
-     *   https://en.wikipedia.org/wiki/List_of_Microsoft_Windows_versions
-     *   https://docs.microsoft.com/en-us/windows/desktop/api/winnt/
-     *     ns-winnt-_osversioninfoexa#remarks
-     */
-    /* Windows Server 2019 is indistinguishable from Windows Server 2016
-     * using GetVersionEx().
-    { 10,  0, NULL,                        "Windows Server 2019" }, */
-    { 10,  0, "Windows 10",                "Windows Server 2016" },
-    {  6,  3, "Windows 8.1",               "Windows Server 2012 R2" },
-    {  6,  2, "Windows 8",                 "Windows Server 2012" },
-    {  6,  1, "Windows 7",                 "Windows Server 2008 R2" },
-    {  6,  0, "Windows Vista",             "Windows Server 2008" },
-    {  5,  2, "Windows XP Professional",   "Windows Server 2003" },
-    /* Windows XP did not have a server version, but we need something here */
-    {  5,  1, "Windows XP",                "Windows XP Server" },
-    {  5,  0, "Windows 2000 Professional", "Windows 2000 Server" },
-    /* Earlier versions are not supported by GetVersionEx(). */
-    {  0,  0, NULL,                        NULL }
-        };
         memset(&info, 0, sizeof(info));
         info.dwOSVersionInfoSize = sizeof(info);
         if (! GetVersionEx((LPOSVERSIONINFO)&info)) {
diff --git a/src/lib/process/waitpid.c b/src/lib/process/waitpid.c
index 89ffe9fcfe..33798f65f0 100644
--- a/src/lib/process/waitpid.c
+++ b/src/lib/process/waitpid.c
@@ -58,9 +58,9 @@ process_map_entries_eq_(const waitpid_callback_t *a,
 static HT_HEAD(process_map, waitpid_callback_t) process_map = HT_INITIALIZER();
 
 HT_PROTOTYPE(process_map, waitpid_callback_t, node, process_map_entry_hash_,
-             process_map_entries_eq_)
+             process_map_entries_eq_);
 HT_GENERATE2(process_map, waitpid_callback_t, node, process_map_entry_hash_,
-             process_map_entries_eq_, 0.6, tor_reallocarray_, tor_free_)
+             process_map_entries_eq_, 0.6, tor_reallocarray_, tor_free_);
 
 /**
  * Begin monitoring the child pid <b>pid</b> to see if we get a SIGCHLD for