restyle fallback module to match project style

Reduces lint errors from 36 to 33 (-8%). Line count from 1910 to 1476 (-23%).

Another step in resolving issue #2902.

This also fixes a stupid mistake from an earlier commit where I didn't realize
that osx/config.h was meant to be included as a semi-static file in the
repository.

3 files changed, 551 insertions, 983 deletions

diff --git a/Makefile.in b/Makefile.in
index b19fe6bb..6172721e 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -850,7 +850,7 @@ style-all:
 #
 distclean: clean
 	$(MAKE) -C $(PCRE2_DIR) distclean || true
-	rm -f config.status config.log config.h Makefile osx/config.h
+	rm -f config.status config.log config.h Makefile
 .PHONY: distclean
 
 #
diff --git a/src/fallback.cpp b/src/fallback.cpp
index b53aec74..7dcaaee7 100644
--- a/src/fallback.cpp
+++ b/src/fallback.cpp
@@ -1,30 +1,26 @@
-/**
-   This file only contains fallback implementations of functions which
-   have been found to be missing or broken by the configuration
-   scripts.
-
-   Many of these functions are more or less broken and
-   incomplete. lrand28_r internally uses the regular (bad) rand_r
-   function, the gettext function doesn't actually do anything, etc.
-*/
+// This file only contains fallback implementations of functions which have been found to be missing
+// or broken by the configuration scripts.
+//
+// Many of these functions are more or less broken and incomplete. lrand28_r internally uses the
+// regular (bad) rand_r function, the gettext function doesn't actually do anything, etc.
 #include "config.h"
 
 // IWYU likes to recommend adding term.h when we want ncurses.h.
 // IWYU pragma: no_include term.h
+#include <assert.h>  // IWYU pragma: keep
+#include <dirent.h>  // IWYU pragma: keep
+#include <errno.h>   // IWYU pragma: keep
+#include <fcntl.h>   // IWYU pragma: keep
+#include <limits.h>  // IWYU pragma: keep
+#include <stdarg.h>  // IWYU pragma: keep
+#include <stdio.h>   // IWYU pragma: keep
 #include <stdlib.h>
-#include <stdio.h>  // IWYU pragma: keep
-#include <unistd.h>
+#include <string.h>
+#include <sys/stat.h>   // IWYU pragma: keep
 #include <sys/types.h>  // IWYU pragma: keep
-#include <sys/stat.h>  // IWYU pragma: keep
-#include <errno.h>  // IWYU pragma: keep
-#include <fcntl.h>  // IWYU pragma: keep
+#include <unistd.h>
 #include <wchar.h>
 #include <wctype.h>
-#include <string.h>
-#include <dirent.h>  // IWYU pragma: keep
-#include <stdarg.h>  // IWYU pragma: keep
-#include <limits.h>  // IWYU pragma: keep
-#include <assert.h>  // IWYU pragma: keep
 #if HAVE_GETTEXT
 #include <libintl.h>
 #endif
@@ -41,72 +37,60 @@
 #include <ncurses/term.h>
 #endif
 #include <signal.h>  // IWYU pragma: keep
-#include <wchar.h>  // IWYU pragma: keep
+#include <wchar.h>   // IWYU pragma: keep
 
 #include "fallback.h"  // IWYU pragma: keep
-#include "util.h"  // IWYU pragma: keep
+#include "util.h"      // IWYU pragma: keep
 
 #ifdef TPUTS_KLUDGE
-
-int tputs(const char *str, int affcnt, int (*fish_putc)(tputs_arg_t))
-{
-    while (*str)
-    {
+int tputs(const char *str, int affcnt, int (*fish_putc)(tputs_arg_t)) {
+    while (*str) {
         fish_putc(*str++);
     }
 }
-
 #endif
 
 #ifdef TPARM_SOLARIS_KLUDGE
-
 #undef tparm
 
-/**
-   Checks for known string values and maps to correct number of parameters.
-*/
-char *tparm_solaris_kludge(char *str, ...)
-{
-    long int param[9] = { };
+/// Checks for known string values and maps to correct number of parameters.
+char *tparm_solaris_kludge(char *str, ...) {
+    long int param[9] = {};
 
     va_list ap;
     va_start(ap, str);
 
-    if ((set_a_foreground && ! strcmp(str, set_a_foreground))
-            || (set_a_background && ! strcmp(str, set_a_background))
-            || (set_foreground && ! strcmp(str, set_foreground))
-            || (set_background && ! strcmp(str, set_background))
-            || (enter_underline_mode && ! strcmp(str, enter_underline_mode))
-            || (exit_underline_mode && ! strcmp(str, exit_underline_mode))
-            || (enter_standout_mode && ! strcmp(str, enter_standout_mode))
-            || (exit_standout_mode && ! strcmp(str, exit_standout_mode))
-            || (flash_screen && ! strcmp(str, flash_screen))
-            || (enter_subscript_mode && ! strcmp(str, enter_subscript_mode))
-            || (exit_subscript_mode && ! strcmp(str, exit_subscript_mode))
-            || (enter_superscript_mode && ! strcmp(str, enter_superscript_mode))
-            || (exit_superscript_mode && ! strcmp(str, exit_superscript_mode))
-            || (enter_blink_mode && ! strcmp(str, enter_blink_mode))
-            || (enter_italics_mode && ! strcmp(str, enter_italics_mode))
-            || (exit_italics_mode && ! strcmp(str, exit_italics_mode))
-            || (enter_reverse_mode && ! strcmp(str, enter_reverse_mode))
-            || (enter_shadow_mode && ! strcmp(str, enter_shadow_mode))
-            || (exit_shadow_mode && ! strcmp(str, exit_shadow_mode))
-            || (enter_secure_mode && ! strcmp(str, enter_secure_mode))
-            || (enter_bold_mode && ! strcmp(str, enter_bold_mode)))
-    {
+    if ((set_a_foreground && !strcmp(str, set_a_foreground)) ||
+        (set_a_background && !strcmp(str, set_a_background)) ||
+        (set_foreground && !strcmp(str, set_foreground)) ||
+        (set_background && !strcmp(str, set_background)) ||
+        (enter_underline_mode && !strcmp(str, enter_underline_mode)) ||
+        (exit_underline_mode && !strcmp(str, exit_underline_mode)) ||
+        (enter_standout_mode && !strcmp(str, enter_standout_mode)) ||
+        (exit_standout_mode && !strcmp(str, exit_standout_mode)) ||
+        (flash_screen && !strcmp(str, flash_screen)) ||
+        (enter_subscript_mode && !strcmp(str, enter_subscript_mode)) ||
+        (exit_subscript_mode && !strcmp(str, exit_subscript_mode)) ||
+        (enter_superscript_mode && !strcmp(str, enter_superscript_mode)) ||
+        (exit_superscript_mode && !strcmp(str, exit_superscript_mode)) ||
+        (enter_blink_mode && !strcmp(str, enter_blink_mode)) ||
+        (enter_italics_mode && !strcmp(str, enter_italics_mode)) ||
+        (exit_italics_mode && !strcmp(str, exit_italics_mode)) ||
+        (enter_reverse_mode && !strcmp(str, enter_reverse_mode)) ||
+        (enter_shadow_mode && !strcmp(str, enter_shadow_mode)) ||
+        (exit_shadow_mode && !strcmp(str, exit_shadow_mode)) ||
+        (enter_secure_mode && !strcmp(str, enter_secure_mode)) ||
+        (enter_bold_mode && !strcmp(str, enter_bold_mode))) {
         param[0] = va_arg(ap, long int);
-    }
-    else if (cursor_address && ! strcmp(str, cursor_address))
-    {
+    } else if (cursor_address && !strcmp(str, cursor_address)) {
         param[0] = va_arg(ap, long int);
         param[1] = va_arg(ap, long int);
     }
 
     va_end(ap);
 
-
-    return tparm(str, param[0], param[1], param[2], param[3],
-                 param[4], param[5],  param[6], param[7], param[8]);
+    return tparm(str, param[0], param[1], param[2], param[3], param[4], param[5], param[6],
+                 param[7], param[8]);
 }
 
 // Re-defining just to make sure nothing breaks further down in this file.
@@ -114,7 +98,6 @@ char *tparm_solaris_kludge(char *str, ...)
 
 #endif
 
-
 #ifndef HAVE_FWPRINTF
 #define INTERNAL_FWPRINTF 1
 #endif
@@ -125,236 +108,185 @@ char *tparm_solaris_kludge(char *str, ...)
 
 #ifdef INTERNAL_FWPRINTF
 
-/**
-   Internal function for the wprintf fallbacks. USed to write the
-   specified number of spaces.
-*/
-static void pad(void (*writer)(wchar_t), int count)
-{
-
+/// Internal function for the wprintf fallbacks. USed to write the specified number of spaces.
+static void pad(void (*writer)(wchar_t), int count) {
     int i;
-    if (count < 0)
-        return;
+    if (count < 0) return;
 
-    for (i=0; i<count; i++)
-    {
+    for (i = 0; i < count; i++) {
         writer(L' ');
     }
 }
 
-/**
-   Generic formatting function. All other string formatting functions
-   are secretly a wrapper around this function. vgprintf does not
-   implement all the filters supported by printf, only those that are
-   currently used by fish. vgprintf internally uses snprintf to
-   implement the number outputs, such as %f and %x.
-
-   Currently supported functionality:
-
-   - precision specification, both through .* and .N
-   - Padding through * and N
-   - Right padding using the - prefix
-   - long versions of all filters thorugh l and ll prefix
-   - Character output using %c
-   - String output through %s
-   - Floating point number output through %f
-   - Integer output through %d, %i, %u, %o, %x and %X
-
-   For a full description on the usage of *printf, see use 'man 3 printf'.
-*/
-static int vgwprintf(void (*writer)(wchar_t),
-                     const wchar_t *filter,
-                     va_list va)
-{
-    const wchar_t *filter_org=filter;
-    int count=0;
-
-    for (; *filter; filter++)
-    {
-        if (*filter == L'%')
-        {
-            int is_long=0;
+/// Generic formatting function. All other string formatting functions are secretly a wrapper around
+/// this function. vgprintf does not implement all the filters supported by printf, only those that
+/// are currently used by fish. vgprintf internally uses snprintf to implement the number outputs,
+/// such as %f and %x.
+///
+/// Currently supported functionality:
+///
+/// - precision specification, both through .* and .N
+/// - Padding through * and N
+/// - Right padding using the - prefix
+/// - long versions of all filters thorugh l and ll prefix
+/// - Character output using %c
+/// - String output through %s
+/// - Floating point number output through %f
+/// - Integer output through %d, %i, %u, %o, %x and %X
+///
+/// For a full description on the usage of *printf, see use 'man 3 printf'.
+static int vgwprintf(void (*writer)(wchar_t), const wchar_t *filter, va_list va) {
+    const wchar_t *filter_org = filter;
+    int count = 0;
+
+    for (; *filter; filter++) {
+        if (*filter == L'%') {
+            int is_long = 0;
             int width = -1;
             filter++;
-            int loop=1;
-            int precision=-1;
+            int loop = 1;
+            int precision = -1;
             int pad_left = 1;
 
-            if (iswdigit(*filter))
-            {
-                width=0;
-                while ((*filter >= L'0') && (*filter <= L'9'))
-                {
-                    width=10*width+(*filter++ - L'0');
+            if (iswdigit(*filter)) {
+                width = 0;
+                while ((*filter >= L'0') && (*filter <= L'9')) {
+                    width = 10 * width + (*filter++ - L'0');
                 }
             }
 
-            while (loop)
-            {
-
-                switch (*filter)
-                {
-                    case L'l':
-                        /* Long variable */
+            while (loop) {
+                switch (*filter) {
+                    case L'l': {
+                        // Long variable.
                         is_long++;
                         filter++;
                         break;
-
-                    case L'*':
-                        /* Set minimum field width */
+                    }
+                    case L'*': {
+                        // Set minimum field width.
                         width = va_arg(va, int);
                         filter++;
                         break;
-
-                    case L'-':
+                    }
+                    case L'-': {
                         filter++;
-                        pad_left=0;
+                        pad_left = 0;
                         break;
-
-                    case L'.':
-                        /*
-                           Set precision.
-                        */
+                    }
+                    case L'.': {
+                        // Set precision.
                         filter++;
-                        if (*filter == L'*')
-                        {
+                        if (*filter == L'*') {
                             precision = va_arg(va, int);
-                        }
-                        else
-                        {
-                            precision=0;
-                            while ((*filter >= L'0') && (*filter <= L'9'))
-                            {
-                                precision=10*precision+(*filter++ - L'0');
+                        } else {
+                            precision = 0;
+                            while ((*filter >= L'0') && (*filter <= L'9')) {
+                                precision = 10 * precision + (*filter++ - L'0');
                             }
                         }
                         break;
-
-                    default:
-                        loop=0;
+                    }
+                    default: {
+                        loop = 0;
                         break;
+                    }
                 }
             }
 
-            switch (*filter)
-            {
-                case L'c':
-                {
+            switch (*filter) {
+                case L'c': {
                     wchar_t c;
 
-                    if ((width >= 0) && pad_left)
-                    {
-                        pad(writer, width-1);
-                        count += maxi(width-1, 0);
+                    if ((width >= 0) && pad_left) {
+                        pad(writer, width - 1);
+                        count += maxi(width - 1, 0);
                     }
 
-                    c = is_long?va_arg(va, wint_t):btowc(va_arg(va, int));
-                    if (precision != 0)
-                        writer(c);
-
+                    c = is_long ? va_arg(va, wint_t) : btowc(va_arg(va, int));
+                    if (precision != 0) writer(c);
 
-                    if ((width >= 0) && !pad_left)
-                    {
-                        pad(writer, width-1);
-                        count += maxi(width-1, 0);
+                    if ((width >= 0) && !pad_left) {
+                        pad(writer, width - 1);
+                        count += maxi(width - 1, 0);
                     }
 
                     count++;
-
                     break;
                 }
-                case L's':
-                {
-
-                    wchar_t *ss=0;
+                case L's': {
+                    wchar_t *ss = 0;
                     wcstring wide_ss;
-                    if (is_long)
-                    {
+                    if (is_long) {
                         ss = va_arg(va, wchar_t *);
-                    }
-                    else
-                    {
-                        char *ns = va_arg(va, char*);
+                    } else {
+                        char *ns = va_arg(va, char *);
 
-                        if (ns)
-                        {
+                        if (ns) {
                             wide_ss = str2wcstring(ns);
                             ss = wide_ss.c_str();
                         }
                     }
 
-                    if (!ss)
-                    {
+                    if (!ss) {
                         return -1;
                     }
 
-                    if ((width >= 0) && pad_left)
-                    {
-                        pad(writer, width-wcslen(ss));
-                        count += maxi(width-wcslen(ss), 0);
+                    if ((width >= 0) && pad_left) {
+                        pad(writer, width - wcslen(ss));
+                        count += maxi(width - wcslen(ss), 0);
                     }
 
-                    wchar_t *s=ss;
+                    wchar_t *s = ss;
                     int precount = count;
 
-                    while (*s)
-                    {
-                        if ((precision > 0) && (precision <= (count-precount)))
-                            break;
-
+                    while (*s) {
+                        if ((precision > 0) && (precision <= (count - precount))) break;
                         writer(*(s++));
                         count++;
                     }
 
-                    if ((width >= 0) && !pad_left)
-                    {
-                        pad(writer, width-wcslen(ss));
-                        count += maxi(width-wcslen(ss), 0);
+                    if ((width >= 0) && !pad_left) {
+                        pad(writer, width - wcslen(ss));
+                        count += maxi(width - wcslen(ss), 0);
                     }
 
                     break;
                 }
-
                 case L'd':
                 case L'i':
                 case L'o':
                 case L'u':
                 case L'x':
-                case L'X':
-                {
+                case L'X': {
                     char str[33];
                     char *pos;
                     char format[16];
                     int len;
 
-                    format[0]=0;
+                    format[0] = 0;
                     strcat(format, "%");
-                    if (precision >= 0)
-                        strcat(format, ".*");
-                    switch (is_long)
-                    {
-                        case 2:
+                    if (precision >= 0) strcat(format, ".*");
+                    switch (is_long) {
+                        case 2: {
                             strcat(format, "ll");
                             break;
-                        case 1:
+                        }
+                        case 1: {
                             strcat(format, "l");
                             break;
+                        }
                     }
 
                     len = strlen(format);
-                    format[len++]=(char)*filter;
-                    format[len]=0;
+                    format[len++] = (char)*filter;
+                    format[len] = 0;
 
-                    switch (*filter)
-                    {
+                    switch (*filter) {
                         case L'd':
-                        case L'i':
-                        {
-
-                            switch (is_long)
-                            {
-                                case 0:
-                                {
+                        case L'i': {
+                            switch (is_long) {
+                                case 0: {
                                     int d = va_arg(va, int);
                                     if (precision >= 0)
                                         snprintf(str, 32, format, precision, d);
@@ -363,9 +295,7 @@ static int vgwprintf(void (*writer)(wchar_t),
 
                                     break;
                                 }
-
-                                case 1:
-                                {
+                                case 1: {
                                     long d = va_arg(va, long);
                                     if (precision >= 0)
                                         snprintf(str, 32, format, precision, d);
@@ -373,9 +303,7 @@ static int vgwprintf(void (*writer)(wchar_t),
                                         snprintf(str, 32, format, d);
                                     break;
                                 }
-
-                                case 2:
-                                {
+                                case 2: {
                                     long long d = va_arg(va, long long);
                                     if (precision >= 0)
                                         snprintf(str, 32, format, precision, d);
@@ -383,25 +311,21 @@ static int vgwprintf(void (*writer)(wchar_t),
                                         snprintf(str, 32, format, d);
                                     break;
                                 }
-
-                                default:
-                                    debug(0, L"Invalid length modifier in string %ls\n", filter_org);
+                                default: {
+                                    debug(0, L"Invalid length modifier in string %ls\n",
+                                          filter_org);
                                     return -1;
+                                }
                             }
                             break;
-
                         }
 
                         case L'u':
                         case L'o':
                         case L'x':
-                        case L'X':
-                        {
-
-                            switch (is_long)
-                            {
-                                case 0:
-                                {
+                        case L'X': {
+                            switch (is_long) {
+                                case 0: {
                                     unsigned d = va_arg(va, unsigned);
                                     if (precision >= 0)
                                         snprintf(str, 32, format, precision, d);
@@ -409,9 +333,7 @@ static int vgwprintf(void (*writer)(wchar_t),
                                         snprintf(str, 32, format, d);
                                     break;
                                 }
-
-                                case 1:
-                                {
+                                case 1: {
                                     unsigned long d = va_arg(va, unsigned long);
                                     if (precision >= 0)
                                         snprintf(str, 32, format, precision, d);
@@ -419,9 +341,7 @@ static int vgwprintf(void (*writer)(wchar_t),
                                         snprintf(str, 32, format, d);
                                     break;
                                 }
-
-                                case 2:
-                                {
+                                case 2: {
                                     unsigned long long d = va_arg(va, unsigned long long);
                                     if (precision >= 0)
                                         snprintf(str, 32, format, precision, d);
@@ -429,39 +349,35 @@ static int vgwprintf(void (*writer)(wchar_t),
                                         snprintf(str, 32, format, d);
                                     break;
                                 }
-
-                                default:
-                                    debug(0, L"Invalid length modifier in string %ls\n", filter_org);
+                                default: {
+                                    debug(0, L"Invalid length modifier in string %ls\n",
+                                          filter_org);
                                     return -1;
+                                }
                             }
                             break;
-
                         }
-
-                        default:
+                        default: {
                             debug(0, L"Invalid filter %ls in string %ls\n", *filter, filter_org);
                             return -1;
-
+                        }
                     }
 
-                    if ((width >= 0) && pad_left)
-                    {
-                        int l = maxi(width-strlen(str), 0);
+                    if ((width >= 0) && pad_left) {
+                        int l = maxi(width - strlen(str), 0);
                         pad(writer, l);
                         count += l;
                     }
 
                     pos = str;
 
-                    while (*pos)
-                    {
+                    while (*pos) {
                         writer(*(pos++));
                         count++;
                     }
 
-                    if ((width >= 0) && !pad_left)
-                    {
-                        int l = maxi(width-strlen(str), 0);
+                    if ((width >= 0) && !pad_left) {
+                        int l = maxi(width - strlen(str), 0);
                         pad(writer, l);
                         count += l;
                     }
@@ -469,39 +385,28 @@ static int vgwprintf(void (*writer)(wchar_t),
                     break;
                 }
 
-                case L'f':
-                {
+                case L'f': {
                     char str[32];
                     char *pos;
                     double val = va_arg(va, double);
 
-                    if (precision>= 0)
-                    {
-                        if (width>= 0)
-                        {
+                    if (precision >= 0) {
+                        if (width >= 0) {
                             snprintf(str, 32, "%*.*f", width, precision, val);
-                        }
-                        else
-                        {
+                        } else {
                             snprintf(str, 32, "%.*f", precision, val);
                         }
-                    }
-                    else
-                    {
-                        if (width>= 0)
-                        {
+                    } else {
+                        if (width >= 0) {
                             snprintf(str, 32, "%*f", width, val);
-                        }
-                        else
-                        {
+                        } else {
                             snprintf(str, 32, "%f", val);
                         }
                     }
 
                     pos = str;
 
-                    while (*pos)
-                    {
+                    while (*pos) {
                         writer(*(pos++));
                         count++;
                     }
@@ -509,26 +414,23 @@ static int vgwprintf(void (*writer)(wchar_t),
                     break;
                 }
 
-                case L'n':
-                {
+                case L'n': {
                     int *n = va_arg(va, int *);
 
                     *n = count;
                     break;
                 }
-                case L'%':
-                {
+                case L'%': {
                     writer('%');
                     count++;
                     break;
                 }
-                default:
+                default: {
                     debug(0, L"Unknown switch %lc in string %ls\n", *filter, filter_org);
                     return -1;
+                }
             }
-        }
-        else
-        {
+        } else {
             writer(*filter);
             count++;
         }
@@ -537,51 +439,36 @@ static int vgwprintf(void (*writer)(wchar_t),
     return count;
 }
 
-/**
-   Holds data for swprintf writer
-*/
-static struct
-{
+/// Holds data for swprintf writer.
+static struct {
     int count;
     int max;
     wchar_t *pos;
-}
-sw_data;
-
-/**
-   Writers for string output
-*/
-static void sw_writer(wchar_t c)
-{
-    if (sw_data.count < sw_data.max)
-        *(sw_data.pos++)=c;
+} sw_data;
+
+/// Writers for string output.
+static void sw_writer(wchar_t c) {
+    if (sw_data.count < sw_data.max) *(sw_data.pos++) = c;
     sw_data.count++;
 }
 
-int vswprintf(wchar_t *out, size_t n, const wchar_t *filter, va_list va)
-{
+int vswprintf(wchar_t *out, size_t n, const wchar_t *filter, va_list va) {
     int written;
 
-    sw_data.pos=out;
-    sw_data.max=n;
-    sw_data.count=0;
-    written=vgwprintf(&sw_writer,
-                      filter,
-                      va);
-    if (written < n)
-    {
+    sw_data.pos = out;
+    sw_data.max = n;
+    sw_data.count = 0;
+    written = vgwprintf(&sw_writer, filter, va);
+    if (written < n) {
         *sw_data.pos = 0;
-    }
-    else
-    {
-        written=-1;
+    } else {
+        written = -1;
     }
 
     return written;
 }
 
-int swprintf(wchar_t *out, size_t n, const wchar_t *filter, ...)
-{
+int swprintf(wchar_t *out, size_t n, const wchar_t *filter, ...) {
     va_list va;
     int written;
 
@@ -591,27 +478,18 @@ int swprintf(wchar_t *out, size_t n, const wchar_t *filter, ...)
     return written;
 }
 
-/**
-   Holds auxiliary data for fwprintf and wprintf writer
-*/
+/// Holds auxiliary data for fwprintf and wprintf writer.
 static FILE *fw_data;
 
-static void fw_writer(wchar_t c)
-{
-    fputwc(c, fw_data);
-}
+static void fw_writer(wchar_t c) { fputwc(c, fw_data); }
 
-/*
-   Writers for file output
-*/
-int vfwprintf(FILE *f, const wchar_t *filter, va_list va)
-{
+/// Writers for file output.
+int vfwprintf(FILE *f, const wchar_t *filter, va_list va) {
     fw_data = f;
     return vgwprintf(&fw_writer, filter, va);
 }
 
-int fwprintf(FILE *f, const wchar_t *filter, ...)
-{
+int fwprintf(FILE *f, const wchar_t *filter, ...) {
     va_list va;
     int written;
 
@@ -621,18 +499,14 @@ int fwprintf(FILE *f, const wchar_t *filter, ...)
     return written;
 }
 
-int vwprintf(const wchar_t *filter, va_list va)
-{
-    return vfwprintf(stdout, filter, va);
-}
+int vwprintf(const wchar_t *filter, va_list va) { return vfwprintf(stdout, filter, va); }
 
-int wprintf(const wchar_t *filter, ...)
-{
+int wprintf(const wchar_t *filter, ...) {
     va_list va;
     int written;
 
     va_start(va, filter);
-    written=vwprintf(filter, va);
+    written = vwprintf(filter, va);
     va_end(va);
     return written;
 }
@@ -640,66 +514,58 @@ int wprintf(const wchar_t *filter, ...)
 #endif
 
 #ifndef HAVE_FGETWC
-wint_t fgetwc(FILE *stream)
-{
+wint_t fgetwc(FILE *stream) {
     wchar_t res;
     mbstate_t state = {};
 
-    while (1)
-    {
+    while (1) {
         int b = fgetc(stream);
-        if (b == EOF)
-        {
+        if (b == EOF) {
             return WEOF;
         }
 
-        if (MB_CUR_MAX == 1) // single-byte locale, all values are legal
+        if (MB_CUR_MAX == 1)  // single-byte locale, all values are legal
         {
             return b;
         }
 
         char bb = b;
         size_t sz = mbrtowc(&res, &bb, 1, &state);
-        switch (sz)
-        {
-            case -1:
+        switch (sz) {
+            case -1: {
                 return WEOF;
-            case -2:
+            }
+            case -2: {
                 break;
-            case 0:
+            }
+            case 0: {
                 return 0;
-            default:
-                return res;
+            }
+            default: { return res; }
         }
     }
 }
 #endif
 
 #ifndef HAVE_FPUTWC
-wint_t fputwc(wchar_t wc, FILE *stream)
-{
+wint_t fputwc(wchar_t wc, FILE *stream) {
     int res = 0;
     mbstate_t state = {};
     char s[MB_CUR_MAX + 1] = {};
 
-    if (MB_CUR_MAX == 1) // single-byte locale (C/POSIX/ISO-8859)
+    if (MB_CUR_MAX == 1)  // single-byte locale (C/POSIX/ISO-8859)
     {
         // If `wc` contains a wide character we emit a question-mark.
-        if (wc & ~0xFF)
-        {
+        if (wc & ~0xFF) {
             wc = '?';
         }
         s[0] = (char)wc;
         res = fputs(s, stream);
-    }
-    else
-    {
+    } else {
         size_t len = wcrtomb(s, wc, &state);
-        if (len == (size_t)-1)
-        {
+        if (len == (size_t)-1) {
             debug(1, L"Wide character %d has no narrow representation", wc);
-        }
-        else {
+        } else {
             res = fputs(s, stream);
         }
     }
@@ -710,21 +576,15 @@ wint_t fputwc(wchar_t wc, FILE *stream)
 
 #ifndef HAVE_WCSTOK
 
-/*
-  Used by fallback wcstok. Borrowed from glibc
-*/
-static size_t fish_wcsspn(const wchar_t *wcs,
-                          const wchar_t *accept)
-{
+/// Used by fallback wcstok. Borrowed from glibc.
+static size_t fish_wcsspn(const wchar_t *wcs, const wchar_t *accept) {
     register const wchar_t *p;
     register const wchar_t *a;
     register size_t count = 0;
 
-    for (p = wcs; *p != L'\0'; ++p)
-    {
+    for (p = wcs; *p != L'\0'; ++p) {
         for (a = accept; *a != L'\0'; ++a)
-            if (*p == *a)
-                break;
+            if (*p == *a) break;
 
         if (*a == L'\0')
             return count;
@@ -734,59 +594,46 @@ static size_t fish_wcsspn(const wchar_t *wcs,
     return count;
 }
 
-/*
-  Used by fallback wcstok. Borrowed from glibc
-*/
-static wchar_t *fish_wcspbrk(const wchar_t *wcs, const wchar_t *accept)
-{
+/// Used by fallback wcstok. Borrowed from glibc.
+static wchar_t *fish_wcspbrk(const wchar_t *wcs, const wchar_t *accept) {
     while (*wcs != L'\0')
         if (wcschr(accept, *wcs) == NULL)
             ++wcs;
         else
-            return (wchar_t *) wcs;
+            return (wchar_t *)wcs;
     return NULL;
 }
 
-/*
-  Fallback wcstok implementation. Borrowed from glibc.
-*/
-wchar_t *wcstok(wchar_t *wcs, const wchar_t *delim, wchar_t **save_ptr)
-{
+/// Fallback wcstok implementation. Borrowed from glibc.
+wchar_t *wcstok(wchar_t *wcs, const wchar_t *delim, wchar_t **save_ptr) {
     wchar_t *result;
 
-    if (wcs == NULL)
-    {
-        if (*save_ptr == NULL)
-        {
+    if (wcs == NULL) {
+        if (*save_ptr == NULL) {
             errno = EINVAL;
             return NULL;
-        }
-        else
+        } else
             wcs = *save_ptr;
     }
 
-    /* Scan leading delimiters.  */
+    // Scan leading delimiters.
     wcs += fish_wcsspn(wcs, delim);
 
-    if (*wcs == L'\0')
-    {
+    if (*wcs == L'\0') {
         *save_ptr = NULL;
         return NULL;
     }
 
-    /* Find the end of the token.  */
+    // Find the end of the token.
     result = wcs;
 
     wcs = fish_wcspbrk(result, delim);
 
-    if (wcs == NULL)
-    {
-        /* This token finishes the string.  */
+    if (wcs == NULL) {
+        // This token finishes the string.
         *save_ptr = NULL;
-    }
-    else
-    {
-        /* Terminate the token and make *SAVE_PTR point past it.  */
+    } else {
+        // Terminate the token and make *SAVE_PTR point past it.
         *wcs = L'\0';
         *save_ptr = wcs + 1;
     }
@@ -795,162 +642,120 @@ wchar_t *wcstok(wchar_t *wcs, const wchar_t *delim, wchar_t **save_ptr)
 
 #endif
 
-/* Fallback implementations of wcsdup and wcscasecmp. On systems where these are not needed (e.g. building on Linux) these should end up just being stripped, as they are static functions that are not referenced in this file.
-*/
-__attribute__((unused))
-static wchar_t *wcsdup_fallback(const wchar_t *in)
-{
-    size_t len=wcslen(in);
-    wchar_t *out = (wchar_t *)malloc(sizeof(wchar_t)*(len+1));
-    if (out == 0)
-    {
+/// Fallback implementations of wcsdup and wcscasecmp. On systems where these are not needed (e.g.
+/// building on Linux) these should end up just being stripped, as they are static functions that
+/// are not referenced in this file.
+__attribute__((unused)) static wchar_t *wcsdup_fallback(const wchar_t *in) {
+    size_t len = wcslen(in);
+    wchar_t *out = (wchar_t *)malloc(sizeof(wchar_t) * (len + 1));
+    if (out == 0) {
         return 0;
     }
 
-    memcpy(out, in, sizeof(wchar_t)*(len+1));
+    memcpy(out, in, sizeof(wchar_t) * (len + 1));
     return out;
 }
 
-__attribute__((unused))
-static int wcscasecmp_fallback(const wchar_t *a, const wchar_t *b)
-{
-    if (*a == 0)
-    {
-        return (*b==0)?0:-1;
-    }
-    else if (*b == 0)
-    {
+__attribute__((unused)) static int wcscasecmp_fallback(const wchar_t *a, const wchar_t *b) {
+    if (*a == 0) {
+        return (*b == 0) ? 0 : -1;
+    } else if (*b == 0) {
         return 1;
     }
-    int diff = towlower(*a)-towlower(*b);
+    int diff = towlower(*a) - towlower(*b);
     if (diff != 0)
         return diff;
     else
-        return wcscasecmp_fallback(a+1,b+1);
+        return wcscasecmp_fallback(a + 1, b + 1);
 }
 
-__attribute__((unused))
-static int wcsncasecmp_fallback(const wchar_t *a, const wchar_t *b, size_t count)
-{
-    if (count == 0)
-        return 0;
+__attribute__((unused)) static int wcsncasecmp_fallback(const wchar_t *a, const wchar_t *b,
+                                                        size_t count) {
+    if (count == 0) return 0;
 
-    if (*a == 0)
-    {
-        return (*b==0)?0:-1;
-    }
-    else if (*b == 0)
-    {
+    if (*a == 0) {
+        return (*b == 0) ? 0 : -1;
+    } else if (*b == 0) {
         return 1;
     }
-    int diff = towlower(*a)-towlower(*b);
+    int diff = towlower(*a) - towlower(*b);
     if (diff != 0)
         return diff;
     else
-        return wcsncasecmp_fallback(a+1,b+1, count-1);
+        return wcsncasecmp_fallback(a + 1, b + 1, count - 1);
 }
 
-
 #if __APPLE__ && __DARWIN_C_LEVEL >= 200809L
-/* Note parens avoid the macro expansion */
-wchar_t *wcsdup_use_weak(const wchar_t *a)
-{
-    if (&wcsdup != NULL)
-        return (wcsdup)(a);
+// Note parens avoid the macro expansion.
+wchar_t *wcsdup_use_weak(const wchar_t *a) {
+    if (&wcsdup != NULL) return (wcsdup)(a);
     return wcsdup_fallback(a);
 }
 
-int wcscasecmp_use_weak(const wchar_t *a, const wchar_t *b)
-{
-    if (&wcscasecmp != NULL)
-        return (wcscasecmp)(a, b);
+int wcscasecmp_use_weak(const wchar_t *a, const wchar_t *b) {
+    if (&wcscasecmp != NULL) return (wcscasecmp)(a, b);
     return wcscasecmp_fallback(a, b);
 }
 
-int wcsncasecmp_use_weak(const wchar_t *s1, const wchar_t *s2, size_t n)
-{
-    if (&wcsncasecmp != NULL)
-        return (wcsncasecmp)(s1, s2, n);
+int wcsncasecmp_use_weak(const wchar_t *s1, const wchar_t *s2, size_t n) {
+    if (&wcsncasecmp != NULL) return (wcsncasecmp)(s1, s2, n);
     return wcsncasecmp_fallback(s1, s2, n);
 }
 
-#else //__APPLE__
+#else  //__APPLE__
 
 #ifndef HAVE_WCSDUP
-wchar_t *wcsdup(const wchar_t *in)
-{
-    return wcsdup_fallback(in);
-
-}
+wchar_t *wcsdup(const wchar_t *in) { return wcsdup_fallback(in); }
 #endif
 
-
 #ifndef HAVE_WCSCASECMP
-int wcscasecmp(const wchar_t *a, const wchar_t *b)
-{
-    return wcscasecmp_fallback(a, b);
-}
+int wcscasecmp(const wchar_t *a, const wchar_t *b) { return wcscasecmp_fallback(a, b); }
 #endif
-#endif //__APPLE__
+#endif  //__APPLE__
 
 #ifndef HAVE_WCSLEN
-size_t wcslen(const wchar_t *in)
-{
-    const wchar_t *end=in;
-    while (*end)
-        end++;
-    return end-in;
+size_t wcslen(const wchar_t *in) {
+    const wchar_t *end = in;
+    while (*end) end++;
+    return end - in;
 }
 #endif
 
 #ifndef HAVE_WCSNCASECMP
-int wcsncasecmp(const wchar_t *a, const wchar_t *b, size_t count)
-{
+int wcsncasecmp(const wchar_t *a, const wchar_t *b, size_t count) {
     return wcsncasecmp_fallback(a, b, count);
 }
 #endif
 
 #ifndef HAVE_WCWIDTH
-int wcwidth(wchar_t c)
-{
-    if (c < 32)
-        return 0;
-    if (c == 127)
-        return 0;
+int wcwidth(wchar_t c) {
+    if (c < 32) return 0;
+    if (c == 127) return 0;
     return 1;
 }
 #endif
 
 #ifndef HAVE_WCSNDUP
-wchar_t *wcsndup(const wchar_t *in, size_t c)
-{
-    wchar_t *res = (wchar_t *)malloc(sizeof(wchar_t)*(c+1));
-    if (res == 0)
-    {
+wchar_t *wcsndup(const wchar_t *in, size_t c) {
+    wchar_t *res = (wchar_t *)malloc(sizeof(wchar_t) * (c + 1));
+    if (res == 0) {
         return 0;
     }
-    wcslcpy(res, in, c+1);
+    wcslcpy(res, in, c + 1);
     return res;
 }
 #endif
 
-long convert_digit(wchar_t d, int base)
-{
-    long res=-1;
-    if ((d <= L'9') && (d >= L'0'))
-    {
+long convert_digit(wchar_t d, int base) {
+    long res = -1;
+    if ((d <= L'9') && (d >= L'0')) {
         res = d - L'0';
-    }
-    else if ((d <= L'z') && (d >= L'a'))
-    {
+    } else if ((d <= L'z') && (d >= L'a')) {
         res = d + 10 - L'a';
-    }
-    else if ((d <= L'Z') && (d >= L'A'))
-    {
+    } else if ((d <= L'Z') && (d >= L'A')) {
         res = d + 10 - L'A';
     }
-    if (res >= base)
-    {
+    if (res >= base) {
         res = -1;
     }
 
@@ -958,40 +763,30 @@ long convert_digit(wchar_t d, int base)
 }
 
 #ifndef HAVE_WCSTOL
-long wcstol(const wchar_t *nptr,
-            wchar_t **endptr,
-            int base)
-{
-    long long res=0;
-    int is_set=0;
-    if (base > 36)
-    {
+long wcstol(const wchar_t *nptr, wchar_t **endptr, int base) {
+    long long res = 0;
+    int is_set = 0;
+    if (base > 36) {
         errno = EINVAL;
         return 0;
     }
 
-    while (1)
-    {
+    while (1) {
         long nxt = convert_digit(*nptr, base);
-        if (endptr != 0)
-            *endptr = (wchar_t *)nptr;
-        if (nxt < 0)
-        {
-            if (!is_set)
-            {
+        if (endptr != 0) *endptr = (wchar_t *)nptr;
+        if (nxt < 0) {
+            if (!is_set) {
                 errno = EINVAL;
             }
             return res;
         }
-        res = (res*base)+nxt;
+        res = (res * base) + nxt;
         is_set = 1;
-        if (res > LONG_MAX)
-        {
+        if (res > LONG_MAX) {
             errno = ERANGE;
             return LONG_MAX;
         }
-        if (res < LONG_MIN)
-        {
+        if (res < LONG_MIN) {
             errno = ERANGE;
             return LONG_MIN;
         }
@@ -1020,29 +815,22 @@ long wcstol(const wchar_t *nptr,
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-size_t
-wcslcat(wchar_t *dst, const wchar_t *src, size_t siz)
-{
-
+size_t wcslcat(wchar_t *dst, const wchar_t *src, size_t siz) {
     register wchar_t *d = dst;
     register const wchar_t *s = src;
     register size_t n = siz;
     size_t dlen;
 
-    /* Find the end of dst and adjust bytes left but don't go past end */
-    while (n-- != 0 && *d != '\0')
-        d++;
+    // Find the end of dst and adjust bytes left but don't go past end.
+    while (n-- != 0 && *d != '\0') d++;
 
     dlen = d - dst;
     n = siz - dlen;
 
-    if (n == 0)
-        return(dlen + wcslen(s));
+    if (n == 0) return (dlen + wcslen(s));
 
-    while (*s != '\0')
-    {
-        if (n != 1)
-        {
+    while (*s != '\0') {
+        if (n != 1) {
             *d++ = *s;
             n--;
         }
@@ -1050,7 +838,7 @@ wcslcat(wchar_t *dst, const wchar_t *src, size_t siz)
     }
     *d = '\0';
 
-    return(dlen + (s - src));
+    return (dlen + (s - src));
     /* count does not include NUL */
 }
 
@@ -1075,49 +863,39 @@ wcslcat(wchar_t *dst, const wchar_t *src, size_t siz)
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-size_t
-wcslcpy(wchar_t *dst, const wchar_t *src, size_t siz)
-{
+size_t wcslcpy(wchar_t *dst, const wchar_t *src, size_t siz) {
     register wchar_t *d = dst;
     register const wchar_t *s = src;
     register size_t n = siz;
 
-    /* Copy as many bytes as will fit */
-    if (n != 0 && --n != 0)
-    {
-        do
-        {
-            if ((*d++ = *s++) == 0)
-                break;
-        }
-        while (--n != 0);
+    // Copy as many bytes as will fit.
+    if (n != 0 && --n != 0) {
+        do {
+            if ((*d++ = *s++) == 0) break;
+        } while (--n != 0);
     }
 
-    /* Not enough room in dst, add NUL and traverse rest of src */
-    if (n == 0)
-    {
-        if (siz != 0)
-            *d = '\0';
-        /* NUL-terminate dst */
+    // Not enough room in dst, add NUL and traverse rest of src.
+    if (n == 0) {
+        if (siz != 0) *d = '\0';
+        // NUL-terminate dst.
         while (*s++)
             ;
     }
-    return(s - src - 1);
-    /* count does not include NUL */
+    return (s - src - 1);
+    // Count does not include NUL.
 }
 
 #endif
 
 #ifndef HAVE_LRAND48_R
 
-int lrand48_r(struct drand48_data *buffer, long int *result)
-{
+int lrand48_r(struct drand48_data *buffer, long int *result) {
     *result = rand_r(&buffer->seed);
     return 0;
 }
 
-int srand48_r(long int seedval, struct drand48_data *buffer)
-{
+int srand48_r(long int seedval, struct drand48_data *buffer) {
     buffer->seed = (unsigned int)seedval;
     return 0;
 }
@@ -1126,8 +904,7 @@ int srand48_r(long int seedval, struct drand48_data *buffer)
 
 #ifndef HAVE_FUTIMES
 
-int futimes(int fd, const struct timeval *times)
-{
+int futimes(int fd, const struct timeval *times) {
     errno = ENOSYS;
     return -1;
 }
@@ -1136,139 +913,98 @@ int futimes(int fd, const struct timeval *times)
 
 #if HAVE_GETTEXT
 
-char * fish_gettext(const char * msgid)
-{
-    return gettext(msgid);;
+char *fish_gettext(const char *msgid) {
+    return gettext(msgid);
+    ;
 }
 
-char * fish_bindtextdomain(const char * domainname, const char * dirname)
-{
+char *fish_bindtextdomain(const char *domainname, const char *dirname) {
     return bindtextdomain(domainname, dirname);
 }
 
-char * fish_textdomain(const char * domainname)
-{
-    return textdomain(domainname);
-}
+char *fish_textdomain(const char *domainname) { return textdomain(domainname); }
 
 #else
 
-char *fish_gettext(const char * msgid)
-{
-    return (char *)msgid;
-}
+char *fish_gettext(const char *msgid) { return (char *)msgid; }
 
-char *fish_bindtextdomain(const char * domainname, const char * dirname)
-{
-    return NULL;
-}
+char *fish_bindtextdomain(const char *domainname, const char *dirname) { return NULL; }
 
-char *fish_textdomain(const char * domainname)
-{
-    return NULL;
-}
+char *fish_textdomain(const char *domainname) { return NULL; }
 
 #endif
 
 #if HAVE_DCGETTEXT
 
-char *fish_dcgettext(const char * domainname, const char * msgid, int category)
-{
+char *fish_dcgettext(const char *domainname, const char *msgid, int category) {
     return dcgettext(domainname, msgid, category);
 }
 
 #else
 
-char *fish_dcgettext(const char * domainname, const char * msgid, int category)
-{
+char *fish_dcgettext(const char *domainname, const char *msgid, int category) {
     return (char *)msgid;
 }
 
-
 #endif
 
 #ifndef HAVE__NL_MSG_CAT_CNTR
 
-int _nl_msg_cat_cntr=0;
+int _nl_msg_cat_cntr = 0;
 
 #endif
 
 #ifndef HAVE_KILLPG
-int killpg(int pgr, int sig)
-{
+int killpg(int pgr, int sig) {
     assert(pgr > 1);
     return kill(-pgr, sig);
 }
 #endif
 
 #ifndef HAVE_BACKTRACE
-int backtrace(void **buffer, int size)
-{
-    return 0;
-}
+int backtrace(void **buffer, int size) { return 0; }
 #endif
 
 #ifndef HAVE_BACKTRACE_SYMBOLS_FD
-char ** backtrace_symbols_fd(void *const *buffer, int size, int fd)
-{
-    return 0;
-}
+char **backtrace_symbols_fd(void *const *buffer, int size, int fd) { return 0; }
 #endif
 
 #ifndef HAVE_SYSCONF
 
-long sysconf(int name)
-{
-    if (name == _SC_ARG_MAX)
-    {
+long sysconf(int name) {
+    if (name == _SC_ARG_MAX) {
 #ifdef ARG_MAX
         return ARG_MAX;
 #endif
     }
 
     return -1;
-
 }
 #endif
 
 #ifndef HAVE_NAN
-double nan(char *tagp)
-{
-    return 0.0/0.0;
-}
+double nan(char *tagp) { return 0.0 / 0.0; }
 #endif
 
-/* Big hack to use our versions of wcswidth where we know them to be broken, like on OS X */
+// Big hack to use our versions of wcswidth where we know them to be broken, like on OS X.
 #ifndef HAVE_BROKEN_WCWIDTH
 #define HAVE_BROKEN_WCWIDTH 1
 #endif
 
-#if ! HAVE_BROKEN_WCWIDTH
+#if !HAVE_BROKEN_WCWIDTH
 
-int fish_wcwidth(wchar_t wc)
-{
-    return wcwidth(wc);
-}
+int fish_wcwidth(wchar_t wc) { return wcwidth(wc); }
 
-int fish_wcswidth(const wchar_t *str, size_t n)
-{
-    return wcswidth(str, n);
-}
+int fish_wcswidth(const wchar_t *str, size_t n) { return wcswidth(str, n); }
 
 #else
 
 static int mk_wcwidth(wchar_t wc);
 static int mk_wcswidth(const wchar_t *pwcs, size_t n);
 
-int fish_wcwidth(wchar_t wc)
-{
-    return mk_wcwidth(wc);
-}
+int fish_wcwidth(wchar_t wc) { return mk_wcwidth(wc); }
 
-int fish_wcswidth(const wchar_t *str, size_t n)
-{
-    return mk_wcswidth(str, n);
-}
+int fish_wcswidth(const wchar_t *str, size_t n) { return mk_wcswidth(str, n); }
 
 /*
  * This is an implementation of wcwidth() and wcswidth() (defined in
@@ -1331,21 +1067,17 @@ int fish_wcswidth(const wchar_t *str, size_t n)
  * Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
  */
 
-struct interval
-{
+struct interval {
     int first;
     int last;
 };
 
-/* auxiliary function for binary search in interval table */
-static int bisearch(wchar_t ucs, const struct interval *table, int max)
-{
+// Auxiliary function for binary search in interval table.
+static int bisearch(wchar_t ucs, const struct interval *table, int max) {
     int min = 0;
 
-    if (ucs < table[0].first || ucs > table[max].last)
-        return 0;
-    while (max >= min)
-    {
+    if (ucs < table[0].first || ucs > table[max].last) return 0;
+    while (max >= min) {
         int mid = (min + max) / 2;
         if (ucs > table[mid].last)
             min = mid + 1;
@@ -1358,135 +1090,104 @@ static int bisearch(wchar_t ucs, const struct interval *table, int max)
     return 0;
 }
 
-
-/* The following two functions define the column width of an ISO 10646
- * character as follows:
- *
- *    - The null character (U+0000) has a column width of 0.
- *
- *    - Other C0/C1 control characters and DEL will lead to a return
- *      value of -1.
- *
- *    - Non-spacing and enclosing combining characters (general
- *      category code Mn or Me in the Unicode database) have a
- *      column width of 0.
- *
- *    - SOFT HYPHEN (U+00AD) has a column width of 1.
- *
- *    - Other format characters (general category code Cf in the Unicode
- *      database) and ZERO WIDTH SPACE (U+200B) have a column width of 0.
- *
- *    - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
- *      have a column width of 0.
- *
- *    - Spacing characters in the East Asian Wide (W) or East Asian
- *      Full-width (F) category as defined in Unicode Technical
- *      Report #11 have a column width of 2.
- *
- *    - All remaining characters (including all printable
- *      ISO 8859-1 and WGL4 characters, Unicode control characters,
- *      etc.) have a column width of 1.
- *
- * This implementation assumes that wchar_t characters are encoded
- * in ISO 10646.
- */
-
-static int mk_wcwidth(wchar_t ucs)
-{
-    /* sorted list of non-overlapping intervals of non-spacing characters */
-    /* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */
-    static const struct interval combining[] =
-    {
-        { 0x0300, 0x036F }, { 0x0483, 0x0486 }, { 0x0488, 0x0489 },
-        { 0x0591, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },
-        { 0x05C4, 0x05C5 }, { 0x05C7, 0x05C7 }, { 0x0600, 0x0603 },
-        { 0x0610, 0x0615 }, { 0x064B, 0x065E }, { 0x0670, 0x0670 },
-        { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED },
-        { 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A },
-        { 0x07A6, 0x07B0 }, { 0x07EB, 0x07F3 }, { 0x0901, 0x0902 },
-        { 0x093C, 0x093C }, { 0x0941, 0x0948 }, { 0x094D, 0x094D },
-        { 0x0951, 0x0954 }, { 0x0962, 0x0963 }, { 0x0981, 0x0981 },
-        { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD },
-        { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C },
-        { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D },
-        { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC },
-        { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD },
-        { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C },
-        { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D },
-        { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 },
-        { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 },
-        { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBC, 0x0CBC },
-        { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD },
-        { 0x0CE2, 0x0CE3 }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D },
-        { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 },
-        { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E },
-        { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC },
-        { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 },
-        { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E },
-        { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 },
-        { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 },
-        { 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 },
-        { 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x135F, 0x135F },
-        { 0x1712, 0x1714 }, { 0x1732, 0x1734 }, { 0x1752, 0x1753 },
-        { 0x1772, 0x1773 }, { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD },
-        { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD },
-        { 0x180B, 0x180D }, { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 },
-        { 0x1927, 0x1928 }, { 0x1932, 0x1932 }, { 0x1939, 0x193B },
-        { 0x1A17, 0x1A18 }, { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 },
-        { 0x1B36, 0x1B3A }, { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 },
-        { 0x1B6B, 0x1B73 }, { 0x1DC0, 0x1DCA }, { 0x1DFE, 0x1DFF },
-        { 0x200B, 0x200F }, { 0x202A, 0x202E }, { 0x2060, 0x2063 },
-        { 0x206A, 0x206F }, { 0x20D0, 0x20EF }, { 0x302A, 0x302F },
-        { 0x3099, 0x309A }, { 0xA806, 0xA806 }, { 0xA80B, 0xA80B },
-        { 0xA825, 0xA826 }, { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F },
-        { 0xFE20, 0xFE23 }, { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB },
-        { 0x10A01, 0x10A03 }, { 0x10A05, 0x10A06 }, { 0x10A0C, 0x10A0F },
-        { 0x10A38, 0x10A3A }, { 0x10A3F, 0x10A3F }, { 0x1D167, 0x1D169 },
-        { 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B }, { 0x1D1AA, 0x1D1AD },
-        { 0x1D242, 0x1D244 }, { 0xE0001, 0xE0001 }, { 0xE0020, 0xE007F },
-        { 0xE0100, 0xE01EF }
-    };
-
-    /* test for 8-bit control characters */
-    if (ucs == 0)
-        return 0;
-    if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
-        return -1;
-
-    /* binary search in table of non-spacing characters */
-    if (bisearch(ucs, combining,
-                 sizeof(combining) / sizeof(struct interval) - 1))
-        return 0;
-
-    /* if we arrive here, ucs is not a combining or C0/C1 control character */
-
-    return 1 +
-           (ucs >= 0x1100 &&
-            (ucs <= 0x115f ||                    /* Hangul Jamo init. consonants */
-             ucs == 0x2329 || ucs == 0x232a ||
-             (ucs >= 0x2e80 && ucs <= 0xa4cf &&
-              ucs != 0x303f) ||                  /* CJK ... Yi */
-             (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */
-             (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
-             (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */
-             (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
-             (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
-             (ucs >= 0xffe0 && ucs <= 0xffe6) ||
-             (ucs >= 0x20000 && ucs <= 0x2fffd) ||
-             (ucs >= 0x30000 && ucs <= 0x3fffd)));
+// The following two functions define the column width of an ISO 10646 character as follows:
+//
+//    - The null character (U+0000) has a column width of 0.
+//
+//    - Other C0/C1 control characters and DEL will lead to a return
+//      value of -1.
+//
+//    - Non-spacing and enclosing combining characters (general
+//      category code Mn or Me in the Unicode database) have a
+//      column width of 0.
+//
+//    - SOFT HYPHEN (U+00AD) has a column width of 1.
+//
+//    - Other format characters (general category code Cf in the Unicode
+//      database) and ZERO WIDTH SPACE (U+200B) have a column width of 0.
+//
+//    - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
+//      have a column width of 0.
+//
+//    - Spacing characters in the East Asian Wide (W) or East Asian
+//      Full-width (F) category as defined in Unicode Technical
+//      Report #11 have a column width of 2.
+//
+//    - All remaining characters (including all printable
+//      ISO 8859-1 and WGL4 characters, Unicode control characters,
+//      etc.) have a column width of 1.
+//
+// This implementation assumes that wchar_t characters are encoded
+// in ISO 10646.
+static int mk_wcwidth(wchar_t ucs) {
+    // Sorted list of non-overlapping intervals of non-spacing characters.
+    // Generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c".
+    static const struct interval combining[] = {
+        {0x0300, 0x036F},   {0x0483, 0x0486},   {0x0488, 0x0489},   {0x0591, 0x05BD},
+        {0x05BF, 0x05BF},   {0x05C1, 0x05C2},   {0x05C4, 0x05C5},   {0x05C7, 0x05C7},
+        {0x0600, 0x0603},   {0x0610, 0x0615},   {0x064B, 0x065E},   {0x0670, 0x0670},
+        {0x06D6, 0x06E4},   {0x06E7, 0x06E8},   {0x06EA, 0x06ED},   {0x070F, 0x070F},
+        {0x0711, 0x0711},   {0x0730, 0x074A},   {0x07A6, 0x07B0},   {0x07EB, 0x07F3},
+        {0x0901, 0x0902},   {0x093C, 0x093C},   {0x0941, 0x0948},   {0x094D, 0x094D},
+        {0x0951, 0x0954},   {0x0962, 0x0963},   {0x0981, 0x0981},   {0x09BC, 0x09BC},
+        {0x09C1, 0x09C4},   {0x09CD, 0x09CD},   {0x09E2, 0x09E3},   {0x0A01, 0x0A02},
+        {0x0A3C, 0x0A3C},   {0x0A41, 0x0A42},   {0x0A47, 0x0A48},   {0x0A4B, 0x0A4D},
+        {0x0A70, 0x0A71},   {0x0A81, 0x0A82},   {0x0ABC, 0x0ABC},   {0x0AC1, 0x0AC5},
+        {0x0AC7, 0x0AC8},   {0x0ACD, 0x0ACD},   {0x0AE2, 0x0AE3},   {0x0B01, 0x0B01},
+        {0x0B3C, 0x0B3C},   {0x0B3F, 0x0B3F},   {0x0B41, 0x0B43},   {0x0B4D, 0x0B4D},
+        {0x0B56, 0x0B56},   {0x0B82, 0x0B82},   {0x0BC0, 0x0BC0},   {0x0BCD, 0x0BCD},
+        {0x0C3E, 0x0C40},   {0x0C46, 0x0C48},   {0x0C4A, 0x0C4D},   {0x0C55, 0x0C56},
+        {0x0CBC, 0x0CBC},   {0x0CBF, 0x0CBF},   {0x0CC6, 0x0CC6},   {0x0CCC, 0x0CCD},
+        {0x0CE2, 0x0CE3},   {0x0D41, 0x0D43},   {0x0D4D, 0x0D4D},   {0x0DCA, 0x0DCA},
+        {0x0DD2, 0x0DD4},   {0x0DD6, 0x0DD6},   {0x0E31, 0x0E31},   {0x0E34, 0x0E3A},
+        {0x0E47, 0x0E4E},   {0x0EB1, 0x0EB1},   {0x0EB4, 0x0EB9},   {0x0EBB, 0x0EBC},
+        {0x0EC8, 0x0ECD},   {0x0F18, 0x0F19},   {0x0F35, 0x0F35},   {0x0F37, 0x0F37},
+        {0x0F39, 0x0F39},   {0x0F71, 0x0F7E},   {0x0F80, 0x0F84},   {0x0F86, 0x0F87},
+        {0x0F90, 0x0F97},   {0x0F99, 0x0FBC},   {0x0FC6, 0x0FC6},   {0x102D, 0x1030},
+        {0x1032, 0x1032},   {0x1036, 0x1037},   {0x1039, 0x1039},   {0x1058, 0x1059},
+        {0x1160, 0x11FF},   {0x135F, 0x135F},   {0x1712, 0x1714},   {0x1732, 0x1734},
+        {0x1752, 0x1753},   {0x1772, 0x1773},   {0x17B4, 0x17B5},   {0x17B7, 0x17BD},
+        {0x17C6, 0x17C6},   {0x17C9, 0x17D3},   {0x17DD, 0x17DD},   {0x180B, 0x180D},
+        {0x18A9, 0x18A9},   {0x1920, 0x1922},   {0x1927, 0x1928},   {0x1932, 0x1932},
+        {0x1939, 0x193B},   {0x1A17, 0x1A18},   {0x1B00, 0x1B03},   {0x1B34, 0x1B34},
+        {0x1B36, 0x1B3A},   {0x1B3C, 0x1B3C},   {0x1B42, 0x1B42},   {0x1B6B, 0x1B73},
+        {0x1DC0, 0x1DCA},   {0x1DFE, 0x1DFF},   {0x200B, 0x200F},   {0x202A, 0x202E},
+        {0x2060, 0x2063},   {0x206A, 0x206F},   {0x20D0, 0x20EF},   {0x302A, 0x302F},
+        {0x3099, 0x309A},   {0xA806, 0xA806},   {0xA80B, 0xA80B},   {0xA825, 0xA826},
+        {0xFB1E, 0xFB1E},   {0xFE00, 0xFE0F},   {0xFE20, 0xFE23},   {0xFEFF, 0xFEFF},
+        {0xFFF9, 0xFFFB},   {0x10A01, 0x10A03}, {0x10A05, 0x10A06}, {0x10A0C, 0x10A0F},
+        {0x10A38, 0x10A3A}, {0x10A3F, 0x10A3F}, {0x1D167, 0x1D169}, {0x1D173, 0x1D182},
+        {0x1D185, 0x1D18B}, {0x1D1AA, 0x1D1AD}, {0x1D242, 0x1D244}, {0xE0001, 0xE0001},
+        {0xE0020, 0xE007F}, {0xE0100, 0xE01EF}};
+
+    // Test for 8-bit control characters.
+    if (ucs == 0) return 0;
+    if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) return -1;
+
+    // Binary search in table of non-spacing characters.
+    if (bisearch(ucs, combining, sizeof(combining) / sizeof(struct interval) - 1)) return 0;
+
+    // If we arrive here, ucs is not a combining or C0/C1 control character.
+    return 1 + (ucs >= 0x1100 &&
+                (ucs <= 0x115f || /* Hangul Jamo init. consonants */
+                 ucs == 0x2329 || ucs == 0x232a ||
+                 (ucs >= 0x2e80 && ucs <= 0xa4cf && ucs != 0x303f) || /* CJK ... Yi */
+                 (ucs >= 0xac00 && ucs <= 0xd7a3) ||                  /* Hangul Syllables */
+                 (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
+                 (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */
+                 (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
+                 (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
+                 (ucs >= 0xffe0 && ucs <= 0xffe6) || (ucs >= 0x20000 && ucs <= 0x2fffd) ||
+                 (ucs >= 0x30000 && ucs <= 0x3fffd)));
 }
 
-static int mk_wcswidth(const wchar_t *pwcs, size_t n)
-{
+static int mk_wcswidth(const wchar_t *pwcs, size_t n) {
     int width = 0;
-    for (size_t i=0; i < n; i++)
-    {
-        if (pwcs[i] == L'\0')
-            break;
+    for (size_t i = 0; i < n; i++) {
+        if (pwcs[i] == L'\0') break;
 
         int w = mk_wcwidth(pwcs[i]);
-        if (w < 0)
-        {
+        if (w < 0) {
             width = -1;
             break;
         }
@@ -1495,4 +1196,4 @@ static int mk_wcswidth(const wchar_t *pwcs, size_t n)
     return width;
 }
 
-#endif // HAVE_BROKEN_WCWIDTH
+#endif  // HAVE_BROKEN_WCWIDTH
diff --git a/src/fallback.h b/src/fallback.h
index ae48e232..ca7a671b 100644
--- a/src/fallback.h
+++ b/src/fallback.h
@@ -7,8 +7,8 @@
 // compiling several modules that include this header because they use symbols which are defined as
 // macros in <term.h>.
 // IWYU pragma: no_include <term.h>
-#include <stdint.h>
 #include <signal.h>
+#include <stdint.h>
 #include <unistd.h>
 // The following include must be kept despite what IWYU says. That's because of the interaction
 // between the weak linking of `wcsdup` and `wcscasecmp` via `#define`s below and the declarations
@@ -19,24 +19,19 @@
 #include <ncurses.h>  // IWYU pragma: keep
 #endif
 
-/** fish's internal versions of wcwidth and wcswidth, which can use an internal implementation if the system one is busted. */
+/// fish's internal versions of wcwidth and wcswidth, which can use an internal implementation if
+/// the system one is busted.
 int fish_wcwidth(wchar_t wc);
 int fish_wcswidth(const wchar_t *str, size_t n);
 
 #ifndef WCHAR_MAX
-/**
-   This _should_ be defined by wchar.h, but e.g. OpenBSD doesn't.
-*/
+/// This _should_ be defined by wchar.h, but e.g. OpenBSD doesn't.
 #define WCHAR_MAX INT_MAX
 #endif
 
-/**
-   Under curses, tputs expects an int (*func)(char) as its last
-   parameter, but in ncurses, tputs expects a int (*func)(int) as its
-   last parameter. tputs_arg_t is defined to always be what tputs
-   expects. Hopefully.
-*/
-
+/// Under curses, tputs expects an int (*func)(char) as its last parameter, but in ncurses, tputs
+/// expects a int (*func)(int) as its last parameter. tputs_arg_t is defined to always be what tputs
+/// expects. Hopefully.
 #ifdef NCURSES_VERSION
 typedef int tputs_arg_t;
 #else
@@ -52,103 +47,60 @@ typedef char tputs_arg_t;
 #endif
 
 #ifndef HAVE_WINSIZE
-/**
-   Structure used to get the size of a terminal window
- */
-struct winsize
-{
-    /**
-       Number of rows
-     */
+/// Structure used to get the size of a terminal window.
+struct winsize {
+    /// Number of rows.
     unsigned short ws_row;
-    /**
-       Number of columns
-     */
+    /// Number of columns.
     unsigned short ws_col;
-}
-;
+};
 
 #endif
 
 #ifdef TPUTS_KLUDGE
 
-/**
-   Linux on PPC seems to have a tputs implementation that sometimes
-   behaves strangely. This fallback seems to fix things.
-*/
+/// Linux on PPC seems to have a tputs implementation that sometimes behaves strangely. This
+/// fallback seems to fix things.
 int tputs(const char *str, int affcnt, int (*fish_putc)(tputs_arg_t));
 
 #endif
 
 #ifdef TPARM_SOLARIS_KLUDGE
-
-/**
-   Solaris tparm has a set fixed of paramters in it's curses implementation,
-   work around this here.
-*/
-
+/// Solaris tparm has a set fixed of paramters in it's curses implementation, work around this here.
 #define tparm tparm_solaris_kludge
 char *tparm_solaris_kludge(char *str, ...);
-
 #endif
 
 #ifndef HAVE_FWPRINTF
-
-/**
-   Print formated string. Some operating systems (Like NetBSD) do not
-   have wide string formating functions.  Therefore we implement our
-   own. Not at all complete. Supports wide and narrow characters,
-   strings and decimal numbers, position (%n), field width and
-   precision.
-*/
+/// Print formated string. Some operating systems (Like NetBSD) do not have wide string formating
+/// functions.  Therefore we implement our own. Not at all complete. Supports wide and narrow
+/// characters, strings and decimal numbers, position (%n), field width and precision.
 int fwprintf(FILE *f, const wchar_t *format, ...);
 
-
-/**
-   Print formated string. Some operating systems (Like NetBSD) do not
-   have wide string formating functions.  Therefore we define our
-   own. Not at all complete. Supports wide and narrow characters,
-   strings and decimal numbers, position (%n), field width and
-   precision.
-*/
+/// Print formated string. Some operating systems (Like NetBSD) do not have wide string formating
+/// functions.  Therefore we define our own. Not at all complete. Supports wide and narrow
+/// characters, strings and decimal numbers, position (%n), field width and precision.
 int swprintf(wchar_t *str, size_t l, const wchar_t *format, ...);
 
-/**
-   Print formated string. Some operating systems (Like NetBSD) do not
-   have wide string formating functions.  Therefore we define our
-   own. Not at all complete. Supports wide and narrow characters,
-   strings and decimal numbers, position (%n), field width and
-   precision.
-*/
+/// Print formated string. Some operating systems (Like NetBSD) do not have wide string formating
+/// functions.  Therefore we define our own. Not at all complete. Supports wide and narrow
+/// characters, strings and decimal numbers, position (%n), field width and precision.
 int wprintf(const wchar_t *format, ...);
 
-/**
-   Print formated string. Some operating systems (Like NetBSD) do not
-   have wide string formating functions.  Therefore we define our
-   own. Not at all complete. Supports wide and narrow characters,
-   strings and decimal numbers, position (%n), field width and
-   precision.
-*/
+/// Print formated string. Some operating systems (Like NetBSD) do not have wide string formating
+/// functions.  Therefore we define our own. Not at all complete. Supports wide and narrow
+/// characters, strings and decimal numbers, position (%n), field width and precision.
 int vwprintf(const wchar_t *filter, va_list va);
 
-/**
-   Print formated string. Some operating systems (Like NetBSD) do not
-   have wide string formating functions.  Therefore we define our
-   own. Not at all complete. Supports wide and narrow characters,
-   strings and decimal numbers, position (%n), field width and
-   precision.
-*/
+/// Print formated string. Some operating systems (Like NetBSD) do not have wide string formating
+/// functions.  Therefore we define our own. Not at all complete. Supports wide and narrow
+/// characters, strings and decimal numbers, position (%n), field width and precision.
 int vfwprintf(FILE *f, const wchar_t *filter, va_list va);
 
-/**
-   Print formated string. Some operating systems (Like NetBSD) do not
-   have wide string formating functions.  Therefore we define our
-   own. Not at all complete. Supports wide and narrow characters,
-   strings and decimal numbers, position (%n), field width and
-   precision.
-*/
+/// Print formated string. Some operating systems (Like NetBSD) do not have wide string formating
+/// functions.  Therefore we define our own. Not at all complete. Supports wide and narrow
+/// characters, strings and decimal numbers, position (%n), field width and precision.
 int vswprintf(wchar_t *out, size_t n, const wchar_t *filter, va_list va);
-
 #endif
 
 #ifndef HAVE_FGETWC
@@ -162,36 +114,28 @@ wint_t fputwc(wchar_t wc, FILE *stream);
 #endif
 
 #ifndef HAVE_WCSTOK
-
-/**
-   Fallback implementation of wcstok. Uses code borrowed from glibc.
-*/
+/// Fallback implementation of wcstok. Uses code borrowed from glibc.
 wchar_t *wcstok(wchar_t *wcs, const wchar_t *delim, wchar_t **ptr);
-
 #endif
 
 #ifndef HAVE_WCWIDTH
-
-/**
-   Return the number of columns used by a character. This is a libc
-   function, but the prototype for this function is missing in some libc
-   implementations.
-
-   Fish has a fallback implementation in case the implementation is
-   missing altogether.  In locales without a native wcwidth, Unicode
-   is probably so broken that it isn't worth trying to implement a
-   real wcwidth. Therefore, the fallback wcwidth assumes any printing
-   character takes up one column and anything else uses 0 columns.
-*/
+/// Return the number of columns used by a character. This is a libc function, but the prototype for
+/// this function is missing in some libc implementations.
+///
+/// Fish has a fallback implementation in case the implementation is missing altogether.  In locales
+/// without a native wcwidth, Unicode is probably so broken that it isn't worth trying to implement
+/// a real wcwidth. Therefore, the fallback wcwidth assumes any printing character takes up one
+/// column and anything else uses 0 columns.
 int wcwidth(wchar_t c);
-
 #endif
 
-
-/** On OS X, use weak linking for wcsdup and wcscasecmp. Weak linking allows you to call the function only if it exists at runtime. You can detect it by testing the function pointer against NULL. To avoid making the callers do that, redefine wcsdup to wcsdup_use_weak, and likewise with wcscasecmp. This lets us use the same binary on SnowLeopard (10.6) and Lion+ (10.7), even though these functions only exist on 10.7+.
-
-    On other platforms, use what's detected at build time.
-*/
+/// On OS X, use weak linking for wcsdup and wcscasecmp. Weak linking allows you to call the
+/// function only if it exists at runtime. You can detect it by testing the function pointer against
+/// NULL. To avoid making the callers do that, redefine wcsdup to wcsdup_use_weak, and likewise with
+/// wcscasecmp. This lets us use the same binary on SnowLeopard (10.6) and Lion+ (10.7), even though
+/// these functions only exist on 10.7+.
+///
+/// On other platforms, use what's detected at build time.
 #if __APPLE__ && __DARWIN_C_LEVEL >= 200809L
 wchar_t *wcsdup_use_weak(const wchar_t *);
 int wcscasecmp_use_weak(const wchar_t *, const wchar_t *);
@@ -203,204 +147,127 @@ int wcsncasecmp_use_weak(const wchar_t *s1, const wchar_t *s2, size_t n);
 #else
 
 #ifndef HAVE_WCSDUP
-
-/**
-   Create a duplicate string. Wide string version of strdup. Will
-   automatically exit if out of memory.
-*/
+/// Create a duplicate string. Wide string version of strdup. Will automatically exit if out of
+/// memory.
 wchar_t *wcsdup(const wchar_t *in);
-
 #endif
 
 #ifndef HAVE_WCSCASECMP
-/**
-   Case insensitive string compare function. Wide string version of
-   strcasecmp.
-
-   This implementation of wcscasecmp does not take into account
-   esoteric locales where uppercase and lowercase do not cleanly
-   transform between each other. Hopefully this should be fine since
-   fish only uses this function with one of the strings supplied by
-   fish and guaranteed to be a sane, english word. Using wcscasecmp on
-   a user-supplied string should be considered a bug.
-*/
+/// Case insensitive string compare function. Wide string version of strcasecmp.
+///
+/// This implementation of wcscasecmp does not take into account esoteric locales where uppercase
+/// and lowercase do not cleanly transform between each other. Hopefully this should be fine since
+/// fish only uses this function with one of the strings supplied by fish and guaranteed to be a
+/// sane, english word. Using wcscasecmp on a user-supplied string should be considered a bug.
 int wcscasecmp(const wchar_t *a, const wchar_t *b);
-
 #endif
-#endif //__APPLE__
-
+#endif  //__APPLE__
 
 #ifndef HAVE_WCSLEN
-
-/**
-   Fallback for wclsen. Returns the length of the specified string.
-*/
+/// Fallback for wclsen. Returns the length of the specified string.
 size_t wcslen(const wchar_t *in);
-
 #endif
 
-
 #ifndef HAVE_WCSNCASECMP
-
-/**
-   Case insensitive string compare function. Wide string version of
-   strncasecmp.
-
-   This implementation of wcsncasecmp does not take into account
-   esoteric locales where uppercase and lowercase do not cleanly
-   transform between each other. Hopefully this should be fine since
-   fish only uses this function with one of the strings supplied by
-   fish and guaranteed to be a sane, english word. Using wcsncasecmp on
-   a user-supplied string should be considered a bug.
-*/
+/// Case insensitive string compare function. Wide string version of strncasecmp.
+///
+/// This implementation of wcsncasecmp does not take into account esoteric locales where uppercase
+/// and lowercase do not cleanly transform between each other. Hopefully this should be fine since
+/// fish only uses this function with one of the strings supplied by fish and guaranteed to be a
+/// sane, english word. Using wcsncasecmp on a user-supplied string should be considered a bug.
 int wcsncasecmp(const wchar_t *a, const wchar_t *b, size_t count);
 
-/**
-   Returns a newly allocated wide character string wich is a copy of
-   the string in, but of length c or shorter. The returned string is
-   always null terminated, and the null is not included in the string
-   length.
-*/
-
+/// Returns a newly allocated wide character string wich is a copy of the string in, but of length c
+/// or shorter. The returned string is always null terminated, and the null is not included in the
+/// string length.
 #endif
 
 #ifndef HAVE_WCSNDUP
-
-/**
-   Fallback for wcsndup function. Returns a copy of \c in, truncated
-   to a maximum length of \c c.
-*/
+/// Fallback for wcsndup function. Returns a copy of \c in, truncated to a maximum length of \c c.
 wchar_t *wcsndup(const wchar_t *in, size_t c);
-
 #endif
 
-/**
-   Converts from wide char to digit in the specified base. If d is not
-   a valid digit in the specified base, return -1. This is a helper
-   function for wcstol, but it is useful itself, so it is exported.
-*/
+/// Converts from wide char to digit in the specified base. If d is not a valid digit in the
+/// specified base, return -1. This is a helper function for wcstol, but it is useful itself, so it
+/// is exported.
 long convert_digit(wchar_t d, int base);
 
 #ifndef HAVE_WCSTOL
-
-/**
-   Fallback implementation. Convert a wide character string to a
-   number in the specified base. This functions is the wide character
-   string equivalent of strtol. For bases of 10 or lower, 0..9 are
-   used to represent numbers. For bases below 36, a-z and A-Z are used
-   to represent numbers higher than 9. Higher bases than 36 are not
-   supported.
-*/
-long wcstol(const wchar_t *nptr,
-            wchar_t **endptr,
-            int base);
-
+/// Fallback implementation. Convert a wide character string to a number in the specified base. This
+/// functions is the wide character string equivalent of strtol. For bases of 10 or lower, 0..9 are
+/// used to represent numbers. For bases below 36, a-z and A-Z are used to represent numbers higher
+/// than 9. Higher bases than 36 are not supported.
+long wcstol(const wchar_t *nptr, wchar_t **endptr, int base);
 #endif
 #ifndef HAVE_WCSLCAT
-
-/**
-   Appends src to string dst of size siz (unlike wcsncat, siz is the
-   full size of dst, not space left).  At most siz-1 characters will be
-   copied.  Always NUL terminates (unless siz <= wcslen(dst)).  Returns
-   wcslen(src) + MIN(siz, wcslen(initial dst)).  If retval >= siz,
-   truncation occurred.
-
-   This is the OpenBSD strlcat function, modified for wide characters,
-   and renamed to reflect this change.
-
-*/
+/// Appends src to string dst of size siz (unlike wcsncat, siz is the full size of dst, not space
+/// left).  At most siz-1 characters will be copied.  Always NUL terminates (unless siz <=
+/// wcslen(dst)).  Returns wcslen(src) + MIN(siz, wcslen(initial dst)).  If retval >= siz,
+/// truncation occurred.
+///
+/// This is the OpenBSD strlcat function, modified for wide characters, and renamed to reflect this
+/// change.
 size_t wcslcat(wchar_t *dst, const wchar_t *src, size_t siz);
-
 #endif
 #ifndef HAVE_WCSLCPY
-
-/**
-   Copy src to string dst of size siz.  At most siz-1 characters will
-   be copied.  Always NUL terminates (unless siz == 0).  Returns
-   wcslen(src); if retval >= siz, truncation occurred.
-
-   This is the OpenBSD strlcpy function, modified for wide characters,
-   and renamed to reflect this change.
-*/
+/// Copy src to string dst of size siz.  At most siz-1 characters will be copied.  Always NUL
+/// terminates (unless siz == 0).  Returns wcslen(src); if retval >= siz, truncation occurred.
+///
+/// This is the OpenBSD strlcpy function, modified for wide characters, and renamed to reflect this
+/// change.
 size_t wcslcpy(wchar_t *dst, const wchar_t *src, size_t siz);
-
 #endif
 
 #ifndef HAVE_LRAND48_R
-
-/**
-   Datastructure for the lrand48_r fallback implementation.
-*/
-struct drand48_data
-{
-    /**
-       Seed value
-    */
+/// Datastructure for the lrand48_r fallback implementation.
+struct drand48_data {
     unsigned int seed;
-}
-;
+};
 
-/**
-   Fallback implementation of lrand48_r. Internally uses rand_r, so it is pretty weak.
-*/
+/// Fallback implementation of lrand48_r. Internally uses rand_r, so it is pretty weak.
 int lrand48_r(struct drand48_data *buffer, long int *result);
 
-/**
-   Fallback implementation of srand48_r, the seed function for lrand48_r.
-*/
+/// Fallback implementation of srand48_r, the seed function for lrand48_r.
 int srand48_r(long int seedval, struct drand48_data *buffer);
-
 #endif
 
 #ifndef HAVE_FUTIMES
-
 int futimes(int fd, const struct timeval *times);
-
 #endif
 
-/* autoconf may fail to detect gettext (645), so don't define a function call gettext or we'll get build errors */
+// autoconf may fail to detect gettext (645), so don't define a function call gettext or we'll get
+// build errors.
 
-/** Cover for gettext() */
-char * fish_gettext(const char * msgid);
+/// Cover for gettext().
+char *fish_gettext(const char *msgid);
 
-/** Cover for bindtextdomain() */
-char * fish_bindtextdomain(const char * domainname, const char * dirname);
+/// Cover for bindtextdomain().
+char *fish_bindtextdomain(const char *domainname, const char *dirname);
 
-/** Cover for textdomain() */
-char * fish_textdomain(const char * domainname);
+/// Cover for textdomain().
+char *fish_textdomain(const char *domainname);
 
-/* Cover for dcgettext */
-char * fish_dcgettext(const char * domainname, const char * msgid, int category);
+/// Cover for dcgettext.
+char *fish_dcgettext(const char *domainname, const char *msgid, int category);
 
 #ifndef HAVE__NL_MSG_CAT_CNTR
-
-/**
-   Some gettext implementation use have this variable, and by
-   increasing it, one can tell the system that the translations need
-   to be reloaded.
-*/
+/// Some gettext implementation use have this variable, and by increasing it, one can tell the
+/// system that the translations need to be reloaded.
 extern int _nl_msg_cat_cntr;
-
 #endif
 
-
 #ifndef HAVE_KILLPG
-/**
-   Send specified signal to specified process group.
- */
+/// Send specified signal to specified process group.
 int killpg(int pgr, int sig);
 #endif
 
 #ifndef HAVE_SYSCONF
-
 #define _SC_ARG_MAX 1
 long sysconf(int name);
-
 #endif
 
 #ifndef HAVE_NAN
 double nan(char *tagp);
 #endif
 
-
 #endif