[fusl] clang-format fusl

fusl/src/stdio/vfwprintf.c

 #include "stdio_impl.h"
 #include <errno.h>
 #include <ctype.h>
 #include <limits.h>
 #include <string.h>
 #include <stdarg.h>
 #include <wchar.h>
 #include <inttypes.h>
 
 /* Convenient bit representation for modifier flags, which all fall
  * within 31 codepoints of the space character. */
 
-#define ALT_FORM   (1U<<('#'-' '))
-#define ZERO_PAD   (1U<<('0'-' '))
-#define LEFT_ADJ   (1U<<('-'-' '))
-#define PAD_POS    (1U<<(' '-' '))
-#define MARK_POS   (1U<<('+'-' '))
-#define GROUPED    (1U<<('\''-' '))
+#define ALT_FORM (1U << ('#' - ' '))
+#define ZERO_PAD (1U << ('0' - ' '))
+#define LEFT_ADJ (1U << ('-' - ' '))
+#define PAD_POS (1U << (' ' - ' '))
+#define MARK_POS (1U << ('+' - ' '))
+#define GROUPED (1U << ('\'' - ' '))
 
-#define FLAGMASK (ALT_FORM|ZERO_PAD|LEFT_ADJ|PAD_POS|MARK_POS|GROUPED)
+#define FLAGMASK (ALT_FORM | ZERO_PAD | LEFT_ADJ | PAD_POS | MARK_POS | GROUPED)
 
 #if UINT_MAX == ULONG_MAX
 #define LONG_IS_INT
 #endif
 
 #if SIZE_MAX != ULONG_MAX || UINTMAX_MAX != ULLONG_MAX
 #define ODD_TYPES
 #endif
 
 /* State machine to accept length modifiers + conversion specifiers.
  * Result is 0 on failure, or an argument type to pop on success. */
 
 enum {
-        BARE, LPRE, LLPRE, HPRE, HHPRE, BIGLPRE,
-        ZTPRE, JPRE,
-        STOP,
-        PTR, INT, UINT, ULLONG,
+  BARE,
+  LPRE,
+  LLPRE,
+  HPRE,
+  HHPRE,
+  BIGLPRE,
+  ZTPRE,
+  JPRE,
+  STOP,
+  PTR,
+  INT,
+  UINT,
+  ULLONG,
 #ifndef LONG_IS_INT
-        LONG, ULONG,
+  LONG,
+  ULONG,
 #else
 #define LONG INT
 #define ULONG UINT
 #endif
-        SHORT, USHORT, CHAR, UCHAR,
+  SHORT,
+  USHORT,
+  CHAR,
+  UCHAR,
 #ifdef ODD_TYPES
-        LLONG, SIZET, IMAX, UMAX, PDIFF, UIPTR,
+  LLONG,
+  SIZET,
+  IMAX,
+  UMAX,
+  PDIFF,
+  UIPTR,
 #else
 #define LLONG ULLONG
 #define SIZET ULONG
 #define IMAX LLONG
 #define UMAX ULLONG
 #define PDIFF LONG
 #define UIPTR ULONG
 #endif
-        DBL, LDBL,
-        NOARG,
-        MAXSTATE
+  DBL,
+  LDBL,
+  NOARG,
+  MAXSTATE
 };
 
-#define S(x) [(x)-'A']
-
-static const unsigned char states[]['z'-'A'+1] = {
-        { /* 0: bare types */
-                S('d') = INT, S('i') = INT,
-                S('o') = UINT, S('u') = UINT, S('x') = UINT, S('X') = UINT,
-                S('e') = DBL, S('f') = DBL, S('g') = DBL, S('a') = DBL,
-                S('E') = DBL, S('F') = DBL, S('G') = DBL, S('A') = DBL,
-                S('c') = CHAR, S('C') = INT,
-                S('s') = PTR, S('S') = PTR, S('p') = UIPTR, S('n') = PTR,
-                S('m') = NOARG,
-                S('l') = LPRE, S('h') = HPRE, S('L') = BIGLPRE,
-                S('z') = ZTPRE, S('j') = JPRE, S('t') = ZTPRE,
-        }, { /* 1: l-prefixed */
-                S('d') = LONG, S('i') = LONG,
-                S('o') = ULONG, S('u') = ULONG, S('x') = ULONG, S('X') = ULONG,
-                S('c') = INT, S('s') = PTR, S('n') = PTR,
-                S('l') = LLPRE,
-        }, { /* 2: ll-prefixed */
-                S('d') = LLONG, S('i') = LLONG,
-                S('o') = ULLONG, S('u') = ULLONG,
-                S('x') = ULLONG, S('X') = ULLONG,
-                S('n') = PTR,
-        }, { /* 3: h-prefixed */
-                S('d') = SHORT, S('i') = SHORT,
-                S('o') = USHORT, S('u') = USHORT,
-                S('x') = USHORT, S('X') = USHORT,
-                S('n') = PTR,
-                S('h') = HHPRE,
-        }, { /* 4: hh-prefixed */
-                S('d') = CHAR, S('i') = CHAR,
-                S('o') = UCHAR, S('u') = UCHAR,
-                S('x') = UCHAR, S('X') = UCHAR,
-                S('n') = PTR,
-        }, { /* 5: L-prefixed */
-                S('e') = LDBL, S('f') = LDBL, S('g') = LDBL, S('a') = LDBL,
-                S('E') = LDBL, S('F') = LDBL, S('G') = LDBL, S('A') = LDBL,
-                S('n') = PTR,
-        }, { /* 6: z- or t-prefixed (assumed to be same size) */
-                S('d') = PDIFF, S('i') = PDIFF,
-                S('o') = SIZET, S('u') = SIZET,
-                S('x') = SIZET, S('X') = SIZET,
-                S('n') = PTR,
-        }, { /* 7: j-prefixed */
-                S('d') = IMAX, S('i') = IMAX,
-                S('o') = UMAX, S('u') = UMAX,
-                S('x') = UMAX, S('X') = UMAX,
-                S('n') = PTR,
-        }
+#define S(x) [(x) - 'A']
+
+static const unsigned char states[]['z' - 'A' + 1] = {
+    {
+        /* 0: bare types */
+        S('d') = INT,   S('i') = INT,  S('o') = UINT,  S('u') = UINT,
+        S('x') = UINT,  S('X') = UINT, S('e') = DBL,   S('f') = DBL,
+        S('g') = DBL,   S('a') = DBL,  S('E') = DBL,   S('F') = DBL,
+        S('G') = DBL,   S('A') = DBL,  S('c') = CHAR,  S('C') = INT,
+        S('s') = PTR,   S('S') = PTR,  S('p') = UIPTR, S('n') = PTR,
+        S('m') = NOARG, S('l') = LPRE, S('h') = HPRE,  S('L') = BIGLPRE,
+        S('z') = ZTPRE, S('j') = JPRE, S('t') = ZTPRE,
+    },
+    {
+        /* 1: l-prefixed */
+        S('d') = LONG, S('i') = LONG, S('o') = ULONG, S('u') = ULONG,
+        S('x') = ULONG, S('X') = ULONG, S('c') = INT, S('s') = PTR,
+        S('n') = PTR, S('l') = LLPRE,
+    },
+    {
+        /* 2: ll-prefixed */
+        S('d') = LLONG, S('i') = LLONG, S('o') = ULLONG, S('u') = ULLONG,
+        S('x') = ULLONG, S('X') = ULLONG, S('n') = PTR,
+    },
+    {
+        /* 3: h-prefixed */
+        S('d') = SHORT, S('i') = SHORT, S('o') = USHORT, S('u') = USHORT,
+        S('x') = USHORT, S('X') = USHORT, S('n') = PTR, S('h') = HHPRE,
+    },
+    {
+        /* 4: hh-prefixed */
+        S('d') = CHAR, S('i') = CHAR, S('o') = UCHAR, S('u') = UCHAR,
+        S('x') = UCHAR, S('X') = UCHAR, S('n') = PTR,
+    },
+    {
+        /* 5: L-prefixed */
+        S('e') = LDBL, S('f') = LDBL, S('g') = LDBL, S('a') = LDBL,
+        S('E') = LDBL, S('F') = LDBL, S('G') = LDBL, S('A') = LDBL,
+        S('n') = PTR,
+    },
+    {
+        /* 6: z- or t-prefixed (assumed to be same size) */
+        S('d') = PDIFF, S('i') = PDIFF, S('o') = SIZET, S('u') = SIZET,
+        S('x') = SIZET, S('X') = SIZET, S('n') = PTR,
+    },
+    {
+        /* 7: j-prefixed */
+        S('d') = IMAX, S('i') = IMAX, S('o') = UMAX, S('u') = UMAX,
+        S('x') = UMAX, S('X') = UMAX, S('n') = PTR,
+    }};
+
+#define OOB(x) ((unsigned)(x) - 'A' > 'z' - 'A')
+
+union arg {
+  uintmax_t i;
+  long double f;
+  void* p;
 };
 
-#define OOB(x) ((unsigned)(x)-'A' > 'z'-'A')
-
-union arg
-{
-        uintmax_t i;
-        long double f;
-        void *p;
-};
-
-static void pop_arg(union arg *arg, int type, va_list *ap)
-{
-        /* Give the compiler a hint for optimizing the switch. */
-        if ((unsigned)type > MAXSTATE) return;
-        switch (type) {
-               case PTR:        arg->p = va_arg(*ap, void *);
-        break; case INT:        arg->i = va_arg(*ap, int);
-        break; case UINT:       arg->i = va_arg(*ap, unsigned int);
+static void pop_arg(union arg* arg, int type, va_list* ap) {
+  /* Give the compiler a hint for optimizing the switch. */
+  if ((unsigned)type > MAXSTATE)
+    return;
+  switch (type) {
+    case PTR:
+      arg->p = va_arg(*ap, void*);
+      break;
+    case INT:
+      arg->i = va_arg(*ap, int);
+      break;
+    case UINT:
+      arg->i = va_arg(*ap, unsigned int);
 #ifndef LONG_IS_INT
-        break; case LONG:       arg->i = va_arg(*ap, long);
-        break; case ULONG:      arg->i = va_arg(*ap, unsigned long);
+      break;
+    case LONG:
+      arg->i = va_arg(*ap, long);
+      break;
+    case ULONG:
+      arg->i = va_arg(*ap, unsigned long);
 #endif
-        break; case ULLONG:     arg->i = va_arg(*ap, unsigned long long);
-        break; case SHORT:      arg->i = (short)va_arg(*ap, int);
-        break; case USHORT:     arg->i = (unsigned short)va_arg(*ap, int);
-        break; case CHAR:       arg->i = (signed char)va_arg(*ap, int);
-        break; case UCHAR:      arg->i = (unsigned char)va_arg(*ap, int);
+      break;
+    case ULLONG:
+      arg->i = va_arg(*ap, unsigned long long);
+      break;
+    case SHORT:
+      arg->i = (short)va_arg(*ap, int);
+      break;
+    case USHORT:
+      arg->i = (unsigned short)va_arg(*ap, int);
+      break;
+    case CHAR:
+      arg->i = (signed char)va_arg(*ap, int);
+      break;
+    case UCHAR:
+      arg->i = (unsigned char)va_arg(*ap, int);
 #ifdef ODD_TYPES
-        break; case LLONG:      arg->i = va_arg(*ap, long long);
-        break; case SIZET:      arg->i = va_arg(*ap, size_t);
-        break; case IMAX:       arg->i = va_arg(*ap, intmax_t);
-        break; case UMAX:       arg->i = va_arg(*ap, uintmax_t);
-        break; case PDIFF:      arg->i = va_arg(*ap, ptrdiff_t);
-        break; case UIPTR:      arg->i = (uintptr_t)va_arg(*ap, void *);
+      break;
+    case LLONG:
+      arg->i = va_arg(*ap, long long);
+      break;
+    case SIZET:
+      arg->i = va_arg(*ap, size_t);
+      break;
+    case IMAX:
+      arg->i = va_arg(*ap, intmax_t);
+      break;
+    case UMAX:
+      arg->i = va_arg(*ap, uintmax_t);
+      break;
+    case PDIFF:
+      arg->i = va_arg(*ap, ptrdiff_t);
+      break;
+    case UIPTR:
+      arg->i = (uintptr_t)va_arg(*ap, void*);
 #endif
-        break; case DBL:        arg->f = va_arg(*ap, double);
-        break; case LDBL:       arg->f = va_arg(*ap, long double);
-        }
+      break;
+    case DBL:
+      arg->f = va_arg(*ap, double);
+      break;
+    case LDBL:
+      arg->f = va_arg(*ap, long double);
+  }
 }
 
-static void out(FILE *f, const wchar_t *s, size_t l)
-{
-        while (l-- && !(f->flags & F_ERR)) fputwc(*s++, f);
+static void out(FILE* f, const wchar_t* s, size_t l) {
+  while (l-- && !(f->flags & F_ERR))
+    fputwc(*s++, f);
 }
 
-static int getint(wchar_t **s) {
-        int i;
-        for (i=0; iswdigit(**s); (*s)++)
-                i = 10*i + (**s-'0');
-        return i;
+static int getint(wchar_t** s) {
+  int i;
+  for (i = 0; iswdigit(**s); (*s)++)
+    i = 10 * i + (**s - '0');
+  return i;
 }
 
-static const char sizeprefix['y'-'a'] = {
-['a'-'a']='L', ['e'-'a']='L', ['f'-'a']='L', ['g'-'a']='L',
-['d'-'a']='j', ['i'-'a']='j', ['o'-'a']='j', ['u'-'a']='j', ['x'-'a']='j',
-['p'-'a']='j'
-};
-
-static int wprintf_core(FILE *f, const wchar_t *fmt, va_list *ap, union arg *nl_arg, int *nl_type)
-{
-        wchar_t *a, *z, *s=(wchar_t *)fmt;
-        unsigned l10n=0, litpct, fl;
-        int w, p;
-        union arg arg;
-        int argpos;
-        unsigned st, ps;
-        int cnt=0, l=0;
-        int i;
-        int t;
-        char *bs;
-        char charfmt[16];
-        wchar_t wc;
-
-        for (;;) {
-                /* Update output count, end loop when fmt is exhausted */
-                if (cnt >= 0) {
-                        if (l > INT_MAX - cnt) {
-                                if (!ferror(f)) errno = EOVERFLOW;
-                                cnt = -1;
-                        } else cnt += l;
-                }
-                if (!*s) break;
-
-                /* Handle literal text and %% format specifiers */
-                for (a=s; *s && *s!='%'; s++);
-                litpct = wcsspn(s, L"%")/2; /* Optimize %%%% runs */
-                z = s+litpct;
-                s += 2*litpct;
-                l = z-a;
-                if (f) out(f, a, l);
-                if (l) continue;
-
-                if (iswdigit(s[1]) && s[2]=='$') {
-                        l10n=1;
-                        argpos = s[1]-'0';
-                        s+=3;
-                } else {
-                        argpos = -1;
-                        s++;
-                }
-
-                /* Read modifier flags */
-                for (fl=0; (unsigned)*s-' '<32 && (FLAGMASK&(1U<<(*s-' '))); s++)
-                        fl |= 1U<<(*s-' ');
-
-                /* Read field width */
-                if (*s=='*') {
-                        if (iswdigit(s[1]) && s[2]=='$') {
-                                l10n=1;
-                                nl_type[s[1]-'0'] = INT;
-                                w = nl_arg[s[1]-'0'].i;
-                                s+=3;
-                        } else if (!l10n) {
-                                w = f ? va_arg(*ap, int) : 0;
-                                s++;
-                        } else return -1;
-                        if (w<0) fl|=LEFT_ADJ, w=-w;
-                } else if ((w=getint(&s))<0) return -1;
-
-                /* Read precision */
-                if (*s=='.' && s[1]=='*') {
-                        if (isdigit(s[2]) && s[3]=='$') {
-                                nl_type[s[2]-'0'] = INT;
-                                p = nl_arg[s[2]-'0'].i;
-                                s+=4;
-                        } else if (!l10n) {
-                                p = f ? va_arg(*ap, int) : 0;
-                                s+=2;
-                        } else return -1;
-                } else if (*s=='.') {
-                        s++;
-                        p = getint(&s);
-                } else p = -1;
-
-                /* Format specifier state machine */
-                st=0;
-                do {
-                        if (OOB(*s)) return -1;
-                        ps=st;
-                        st=states[st]S(*s++);
-                } while (st-1<STOP);
-                if (!st) return -1;
-
-                /* Check validity of argument type (nl/normal) */
-                if (st==NOARG) {
-                        if (argpos>=0) return -1;
-                } else {
-                        if (argpos>=0) nl_type[argpos]=st, arg=nl_arg[argpos];
-                        else if (f) pop_arg(&arg, st, ap);
-                        else return 0;
-                }
-
-                if (!f) continue;
-                t = s[-1];
-                if (ps && (t&15)==3) t&=~32;
-
-                switch (t) {
-                case 'n':
-                        switch(ps) {
-                        case BARE: *(int *)arg.p = cnt; break;
-                        case LPRE: *(long *)arg.p = cnt; break;
-                        case LLPRE: *(long long *)arg.p = cnt; break;
-                        case HPRE: *(unsigned short *)arg.p = cnt; break;
-                        case HHPRE: *(unsigned char *)arg.p = cnt; break;
-                        case ZTPRE: *(size_t *)arg.p = cnt; break;
-                        case JPRE: *(uintmax_t *)arg.p = cnt; break;
-                        }
-                        continue;
-                case 'c':
-                        fputwc(btowc(arg.i), f);
-                        l = 1;
-                        continue;
-                case 'C':
-                        fputwc(arg.i, f);
-                        l = 1;
-                        continue;
-                case 'S':
-                        a = arg.p;
-                        z = wmemchr(a, 0, p);
-                        if (z) p=z-a;
-                        if (w<p) w=p;
-                        if (!(fl&LEFT_ADJ)) fprintf(f, "%.*s", w-p, "");
-                        out(f, a, p);
-                        if ((fl&LEFT_ADJ)) fprintf(f, "%.*s", w-p, "");
-                        l=w;
-                        continue;
-                case 'm':
-                        arg.p = strerror(errno);
-                case 's':
-                        if (!arg.p) arg.p = "(null)";
-                        bs = arg.p;
-                        if (p<0) p = INT_MAX;
-                        for (i=l=0; l<p && (i=mbtowc(&wc, bs, MB_LEN_MAX))>0; bs+=i, l++);
-                        if (i<0) return -1;
-                        p=l;
-                        if (w<p) w=p;
-                        if (!(fl&LEFT_ADJ)) fprintf(f, "%.*s", w-p, "");
-                        bs = arg.p;
-                        while (l--) {
-                                i=mbtowc(&wc, bs, MB_LEN_MAX);
-                                bs+=i;
-                                fputwc(wc, f);
-                        }
-                        if ((fl&LEFT_ADJ)) fprintf(f, "%.*s", w-p, "");
-                        l=w;
-                        continue;
-                }
-
-                snprintf(charfmt, sizeof charfmt, "%%%s%s%s%s%s*.*%c%c",
-                        (fl & ALT_FORM) ? "#" : "",
-                        (fl & MARK_POS) ? "+" : "",
-                        (fl & LEFT_ADJ) ? "-" : "",
-                        (fl & PAD_POS) ? " " : "",
-                        (fl & ZERO_PAD) ? "0" : "",
-                        sizeprefix[(t|32)-'a'], t);
-
-                switch (t|32) {
-                case 'a': case 'e': case 'f': case 'g':
-                        l = fprintf(f, charfmt, w, p, arg.f);
-                        break;
-                case 'd': case 'i': case 'o': case 'u': case 'x': case 'p':
-                        l = fprintf(f, charfmt, w, p, arg.i);
-                        break;
-                }
-        }
-
-        if (f) return cnt;
-        if (!l10n) return 0;
-
-        for (i=1; i<=NL_ARGMAX && nl_type[i]; i++)
-                pop_arg(nl_arg+i, nl_type[i], ap);
-        for (; i<=NL_ARGMAX && !nl_type[i]; i++);
-        if (i<=NL_ARGMAX) return -1;
-        return 1;
+static const char sizeprefix['y' - 'a'] =
+    {['a' - 'a'] = 'L', ['e' - 'a'] = 'L', ['f' - 'a'] = 'L', ['g' - 'a'] = 'L',
+     ['d' - 'a'] = 'j', ['i' - 'a'] = 'j', ['o' - 'a'] = 'j', ['u' - 'a'] = 'j',
+     ['x' - 'a'] = 'j', ['p' - 'a'] = 'j'};
+
+static int wprintf_core(FILE* f,
+                        const wchar_t* fmt,
+                        va_list* ap,
+                        union arg* nl_arg,
+                        int* nl_type) {
+  wchar_t *a, *z, *s = (wchar_t *)fmt;
+  unsigned l10n = 0, litpct, fl;
+  int w, p;
+  union arg arg;
+  int argpos;
+  unsigned st, ps;
+  int cnt = 0, l = 0;
+  int i;
+  int t;
+  char* bs;
+  char charfmt[16];
+  wchar_t wc;
+
+  for (;;) {
+    /* Update output count, end loop when fmt is exhausted */
+    if (cnt >= 0) {
+      if (l > INT_MAX - cnt) {
+        if (!ferror(f))
+          errno = EOVERFLOW;
+        cnt = -1;
+      } else
+        cnt += l;
+    }
+    if (!*s)
+      break;
+
+    /* Handle literal text and %% format specifiers */
+    for (a = s; *s && *s != '%'; s++)
+      ;
+    litpct = wcsspn(s, L"%") / 2; /* Optimize %%%% runs */
+    z = s + litpct;
+    s += 2 * litpct;
+    l = z - a;
+    if (f)
+      out(f, a, l);
+    if (l)
+      continue;
+
+    if (iswdigit(s[1]) && s[2] == '$') {
+      l10n = 1;
+      argpos = s[1] - '0';
+      s += 3;
+    } else {
+      argpos = -1;
+      s++;
+    }
+
+    /* Read modifier flags */
+    for (fl = 0; (unsigned)*s - ' ' < 32 && (FLAGMASK & (1U << (*s - ' ')));
+         s++)
+      fl |= 1U << (*s - ' ');
+
+    /* Read field width */
+    if (*s == '*') {
+      if (iswdigit(s[1]) && s[2] == '$') {
+        l10n = 1;
+        nl_type[s[1] - '0'] = INT;
+        w = nl_arg[s[1] - '0'].i;
+        s += 3;
+      } else if (!l10n) {
+        w = f ? va_arg(*ap, int) : 0;
+        s++;
+      } else
+        return -1;
+      if (w < 0)
+        fl |= LEFT_ADJ, w = -w;
+    } else if ((w = getint(&s)) < 0)
+      return -1;
+
+    /* Read precision */
+    if (*s == '.' && s[1] == '*') {
+      if (isdigit(s[2]) && s[3] == '$') {
+        nl_type[s[2] - '0'] = INT;
+        p = nl_arg[s[2] - '0'].i;
+        s += 4;
+      } else if (!l10n) {
+        p = f ? va_arg(*ap, int) : 0;
+        s += 2;
+      } else
+        return -1;
+    } else if (*s == '.') {
+      s++;
+      p = getint(&s);
+    } else
+      p = -1;
+
+    /* Format specifier state machine */
+    st = 0;
+    do {
+      if (OOB(*s))
+        return -1;
+      ps = st;
+      st = states[st] S(*s++);
+    } while (st - 1 < STOP);
+    if (!st)
+      return -1;
+
+    /* Check validity of argument type (nl/normal) */
+    if (st == NOARG) {
+      if (argpos >= 0)
+        return -1;
+    } else {
+      if (argpos >= 0)
+        nl_type[argpos] = st, arg = nl_arg[argpos];
+      else if (f)
+        pop_arg(&arg, st, ap);
+      else
+        return 0;
+    }
+
+    if (!f)
+      continue;
+    t = s[-1];
+    if (ps && (t & 15) == 3)
+      t &= ~32;
+
+    switch (t) {
+      case 'n':
+        switch (ps) {
+          case BARE:
+            *(int*)arg.p = cnt;
+            break;
+          case LPRE:
+            *(long*)arg.p = cnt;
+            break;
+          case LLPRE:
+            *(long long*)arg.p = cnt;
+            break;
+          case HPRE:
+            *(unsigned short*)arg.p = cnt;
+            break;
+          case HHPRE:
+            *(unsigned char*)arg.p = cnt;
+            break;
+          case ZTPRE:
+            *(size_t*)arg.p = cnt;
+            break;
+          case JPRE:
+            *(uintmax_t*)arg.p = cnt;
+            break;
+        }
+        continue;
+      case 'c':
+        fputwc(btowc(arg.i), f);
+        l = 1;
+        continue;
+      case 'C':
+        fputwc(arg.i, f);
+        l = 1;
+        continue;
+      case 'S':
+        a = arg.p;
+        z = wmemchr(a, 0, p);
+        if (z)
+          p = z - a;
+        if (w < p)
+          w = p;
+        if (!(fl & LEFT_ADJ))
+          fprintf(f, "%.*s", w - p, "");
+        out(f, a, p);
+        if ((fl & LEFT_ADJ))
+          fprintf(f, "%.*s", w - p, "");
+        l = w;
+        continue;
+      case 'm':
+        arg.p = strerror(errno);
+      case 's':
+        if (!arg.p)
+          arg.p = "(null)";
+        bs = arg.p;
+        if (p < 0)
+          p = INT_MAX;
+        for (i = l = 0; l < p && (i = mbtowc(&wc, bs, MB_LEN_MAX)) > 0;
+             bs += i, l++)
+          ;
+        if (i < 0)
+          return -1;
+        p = l;
+        if (w < p)
+          w = p;
+        if (!(fl & LEFT_ADJ))
+          fprintf(f, "%.*s", w - p, "");
+        bs = arg.p;
+        while (l--) {
+          i = mbtowc(&wc, bs, MB_LEN_MAX);
+          bs += i;
+          fputwc(wc, f);
+        }
+        if ((fl & LEFT_ADJ))
+          fprintf(f, "%.*s", w - p, "");
+        l = w;
+        continue;
+    }
+
+    snprintf(charfmt, sizeof charfmt, "%%%s%s%s%s%s*.*%c%c",
+             (fl & ALT_FORM) ? "#" : "", (fl & MARK_POS) ? "+" : "",
+             (fl & LEFT_ADJ) ? "-" : "", (fl & PAD_POS) ? " " : "",
+             (fl & ZERO_PAD) ? "0" : "", sizeprefix[(t | 32) - 'a'], t);
+
+    switch (t | 32) {
+      case 'a':
+      case 'e':
+      case 'f':
+      case 'g':
+        l = fprintf(f, charfmt, w, p, arg.f);
+        break;
+      case 'd':
+      case 'i':
+      case 'o':
+      case 'u':
+      case 'x':
+      case 'p':
+        l = fprintf(f, charfmt, w, p, arg.i);
+        break;
+    }
+  }
+
+  if (f)
+    return cnt;
+  if (!l10n)
+    return 0;
+
+  for (i = 1; i <= NL_ARGMAX && nl_type[i]; i++)
+    pop_arg(nl_arg + i, nl_type[i], ap);
+  for (; i <= NL_ARGMAX && !nl_type[i]; i++)
+    ;
+  if (i <= NL_ARGMAX)
+    return -1;
+  return 1;
 }
 
-int vfwprintf(FILE *restrict f, const wchar_t *restrict fmt, va_list ap)
-{
-        va_list ap2;
-        int nl_type[NL_ARGMAX] = {0};
-        union arg nl_arg[NL_ARGMAX];
-        int olderr;
-        int ret;
-
-        /* the copy allows passing va_list* even if va_list is an array */
-        va_copy(ap2, ap);
-        if (wprintf_core(0, fmt, &ap2, nl_arg, nl_type) < 0) {
-                va_end(ap2);
-                return -1;
-        }
-
-        FLOCK(f);
-        fwide(f, 1);
-        olderr = f->flags & F_ERR;
-        f->flags &= ~F_ERR;
-        ret = wprintf_core(f, fmt, &ap2, nl_arg, nl_type);
-        if (f->flags & F_ERR) ret = -1;
-        f->flags |= olderr;
-        FUNLOCK(f);
-        va_end(ap2);
-        return ret;
+int vfwprintf(FILE* restrict f, const wchar_t* restrict fmt, va_list ap) {
+  va_list ap2;
+  int nl_type[NL_ARGMAX] = {0};
+  union arg nl_arg[NL_ARGMAX];
+  int olderr;
+  int ret;
+
+  /* the copy allows passing va_list* even if va_list is an array */
+  va_copy(ap2, ap);
+  if (wprintf_core(0, fmt, &ap2, nl_arg, nl_type) < 0) {
+    va_end(ap2);
+    return -1;
+  }
+
+  FLOCK(f);
+  fwide(f, 1);
+  olderr = f->flags & F_ERR;
+  f->flags &= ~F_ERR;
+  ret = wprintf_core(f, fmt, &ap2, nl_arg, nl_type);
+  if (f->flags & F_ERR)
+    ret = -1;
+  f->flags |= olderr;
+  FUNLOCK(f);
+  va_end(ap2);
+  return ret;
 }