mozglue/misc/Printf.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 * Portable safe sprintf code.
 *
 * Author: Kipp E.B. Hickman
 */

#include "double-conversion/double-conversion.h"
#include "mozilla/AllocPolicy.h"
#include "mozilla/Likely.h"
#include "mozilla/Printf.h"
#include "mozilla/Sprintf.h"
#include "mozilla/UniquePtrExtensions.h"
#include "mozilla/Vector.h"

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if defined(XP_WIN)
#  include <windows.h>
#endif

using double_conversion::DoubleToStringConverter;
using DTSC = DoubleToStringConverter;

/*
 * Note: on some platforms va_list is defined as an array,
 * and requires array notation.
 */
#ifdef HAVE_VA_COPY
#  define VARARGS_ASSIGN(foo, bar) VA_COPY(foo, bar)
#elif defined(HAVE_VA_LIST_AS_ARRAY)
#  define VARARGS_ASSIGN(foo, bar) foo[0] = bar[0]
#else
#  define VARARGS_ASSIGN(foo, bar) (foo) = (bar)
#endif

/*
 * Numbered Argument State
 */
struct NumArgState {
  int type;    // type of the current ap
  va_list ap;  // point to the corresponding position on ap
};

using NumArgStateVector =
    mozilla::Vector<NumArgState, 20, mozilla::MallocAllocPolicy>;

// For values up to and including TYPE_DOUBLE, the lowest bit indicates
// whether the type is signed (0) or unsigned (1).
#define TYPE_SHORT 0
#define TYPE_USHORT 1
#define TYPE_INTN 2
#define TYPE_UINTN 3
#define TYPE_LONG 4
#define TYPE_ULONG 5
#define TYPE_LONGLONG 6
#define TYPE_ULONGLONG 7
#define TYPE_DOUBLE 8
#define TYPE_STRING 9
#define TYPE_INTSTR 10
#define TYPE_POINTER 11
#if defined(XP_WIN)
#  define TYPE_WSTRING 12
#endif
#define TYPE_SCHAR 14
#define TYPE_UCHAR 15
#define TYPE_UNKNOWN 20

#define FLAG_LEFT 0x1
#define FLAG_SIGNED 0x2
#define FLAG_SPACED 0x4
#define FLAG_ZEROS 0x8
#define FLAG_NEG 0x10

static const char hex[] = "0123456789abcdef";
static const char HEX[] = "0123456789ABCDEF";

// Fill into the buffer using the data in src
bool mozilla::PrintfTarget::fill2(const char* src, int srclen, int width,
                                  int flags) {
  char space = ' ';

  width -= srclen;
  if (width > 0 && (flags & FLAG_LEFT) == 0) {  // Right adjusting
    if (flags & FLAG_ZEROS) {
      space = '0';
    }
    while (--width >= 0) {
      if (!emit(&space, 1)) {
        return false;
      }
    }
  }

  // Copy out the source data
  if (!emit(src, srclen)) {
    return false;
  }

  if (width > 0 && (flags & FLAG_LEFT) != 0) {  // Left adjusting
    while (--width >= 0) {
      if (!emit(&space, 1)) {
        return false;
      }
    }
  }
  return true;
}

/*
 * Fill a number. The order is: optional-sign zero-filling conversion-digits
 */
bool mozilla::PrintfTarget::fill_n(const char* src, int srclen, int width,
                                   int prec, int type, int flags) {
  int zerowidth = 0;
  int precwidth = 0;
  int signwidth = 0;
  int leftspaces = 0;
  int rightspaces = 0;
  int cvtwidth;
  char sign;

  if ((type & 1) == 0) {
    if (flags & FLAG_NEG) {
      sign = '-';
      signwidth = 1;
    } else if (flags & FLAG_SIGNED) {
      sign = '+';
      signwidth = 1;
    } else if (flags & FLAG_SPACED) {
      sign = ' ';
      signwidth = 1;
    }
  }
  cvtwidth = signwidth + srclen;

  if (prec > 0 && (type != TYPE_DOUBLE)) {
    if (prec > srclen) {
      precwidth = prec - srclen;  // Need zero filling
      cvtwidth += precwidth;
    }
  }

  if ((flags & FLAG_ZEROS) && ((type == TYPE_DOUBLE) || (prec < 0))) {
    if (width > cvtwidth) {
      zerowidth = width - cvtwidth;  // Zero filling
      cvtwidth += zerowidth;
    }
  }

  if (flags & FLAG_LEFT) {
    if (width > cvtwidth) {
      // Space filling on the right (i.e. left adjusting)
      rightspaces = width - cvtwidth;
    }
  } else {
    if (width > cvtwidth) {
      // Space filling on the left (i.e. right adjusting)
      leftspaces = width - cvtwidth;
    }
  }
  while (--leftspaces >= 0) {
    if (!emit(" ", 1)) {
      return false;
    }
  }
  if (signwidth) {
    if (!emit(&sign, 1)) {
      return false;
    }
  }
  while (--precwidth >= 0) {
    if (!emit("0", 1)) {
      return false;
    }
  }
  while (--zerowidth >= 0) {
    if (!emit("0", 1)) {
      return false;
    }
  }
  if (!emit(src, uint32_t(srclen))) {
    return false;
  }
  while (--rightspaces >= 0) {
    if (!emit(" ", 1)) {
      return false;
    }
  }
  return true;
}

// All that the cvt_* functions care about as far as the TYPE_* constants is
// that the low bit is set to indicate unsigned, or unset to indicate signed.
// So we don't try to hard to ensure that the passed TYPE_* constant lines
// up with the actual size of the number being printed here.  The main printf
// code, below, does have to care so that the correct bits are extracted from
// the varargs list.
bool mozilla::PrintfTarget::appendIntDec(int32_t num) {
  int flags = 0;
  long n = num;
  if (n < 0) {
    n = -n;
    flags |= FLAG_NEG;
  }
  return cvt_l(n, -1, -1, 10, TYPE_INTN, flags, hex);
}

bool mozilla::PrintfTarget::appendIntDec(uint32_t num) {
  return cvt_l(num, -1, -1, 10, TYPE_UINTN, 0, hex);
}

bool mozilla::PrintfTarget::appendIntOct(uint32_t num) {
  return cvt_l(num, -1, -1, 8, TYPE_UINTN, 0, hex);
}

bool mozilla::PrintfTarget::appendIntHex(uint32_t num) {
  return cvt_l(num, -1, -1, 16, TYPE_UINTN, 0, hex);
}

bool mozilla::PrintfTarget::appendIntDec(int64_t num) {
  int flags = 0;
  if (num < 0) {
    num = -num;
    flags |= FLAG_NEG;
  }
  return cvt_ll(num, -1, -1, 10, TYPE_INTN, flags, hex);
}

bool mozilla::PrintfTarget::appendIntDec(uint64_t num) {
  return cvt_ll(num, -1, -1, 10, TYPE_UINTN, 0, hex);
}

bool mozilla::PrintfTarget::appendIntOct(uint64_t num) {
  return cvt_ll(num, -1, -1, 8, TYPE_UINTN, 0, hex);
}

bool mozilla::PrintfTarget::appendIntHex(uint64_t num) {
  return cvt_ll(num, -1, -1, 16, TYPE_UINTN, 0, hex);
}

/* Convert a long into its printable form. */
bool mozilla::PrintfTarget::cvt_l(long num, int width, int prec, int radix,
                                  int type, int flags, const char* hexp) {
  char cvtbuf[100];
  char* cvt;
  int digits;

  // according to the man page this needs to happen
  if ((prec == 0) && (num == 0)) {
    return fill_n("", 0, width, prec, type, flags);
  }

  // Converting decimal is a little tricky. In the unsigned case we
  // need to stop when we hit 10 digits. In the signed case, we can
  // stop when the number is zero.
  cvt = cvtbuf + sizeof(cvtbuf);
  digits = 0;
  while (num) {
    int digit = (((unsigned long)num) % radix) & 0xF;
    *--cvt = hexp[digit];
    digits++;
    num = (long)(((unsigned long)num) / radix);
  }
  if (digits == 0) {
    *--cvt = '0';
    digits++;
  }

  // Now that we have the number converted without its sign, deal with
  // the sign and zero padding.
  return fill_n(cvt, digits, width, prec, type, flags);
}

/* Convert a 64-bit integer into its printable form. */
bool mozilla::PrintfTarget::cvt_ll(int64_t num, int width, int prec, int radix,
                                   int type, int flags, const char* hexp) {
  // According to the man page, this needs to happen.
  if (prec == 0 && num == 0) {
    return fill_n("", 0, width, prec, type, flags);
  }

  // Converting decimal is a little tricky. In the unsigned case we
  // need to stop when we hit 10 digits. In the signed case, we can
  // stop when the number is zero.
  int64_t rad = int64_t(radix);
  char cvtbuf[100];
  char* cvt = cvtbuf + sizeof(cvtbuf);
  int digits = 0;
  while (num != 0) {
    int64_t quot = uint64_t(num) / rad;
    int64_t rem = uint64_t(num) % rad;
    int32_t digit = int32_t(rem);
    *--cvt = hexp[digit & 0xf];
    digits++;
    num = quot;
  }
  if (digits == 0) {
    *--cvt = '0';
    digits++;
  }

  // Now that we have the number converted without its sign, deal with
  // the sign and zero padding.
  return fill_n(cvt, digits, width, prec, type, flags);
}

template <size_t N>
constexpr static size_t lengthof(const char (&)[N]) {
  return N - 1;
}

// Longest possible output from ToFixed for positive numbers:
// [0-9]{kMaxFixedDigitsBeforePoint}\.[0-9]{kMaxFixedDigitsAfterPoint}?
constexpr int FIXED_MAX_CHARS =
    DTSC::kMaxFixedDigitsBeforePoint + 1 + DTSC::kMaxFixedDigitsAfterPoint;

// Longest possible output from ToExponential:
// [1-9]\.[0-9]{kMaxExponentialDigits}e[+-][0-9]{1,3}
// (std::numeric_limits<double>::max() has exponent 308).
constexpr int EXPONENTIAL_MAX_CHARS =
    lengthof("1.") + DTSC::kMaxExponentialDigits + lengthof("e+999");

// Longest possible output from ToPrecise:
// [0-9\.]{kMaxPrecisionDigits+1} or
// [1-9]\.[0-9]{kMaxPrecisionDigits-1}e[+-][0-9]{1,3}
constexpr int PRECISE_MAX_CHARS =
    lengthof("1.") + DTSC::kMaxPrecisionDigits - 1 + lengthof("e+999");

constexpr int DTSC_MAX_CHARS =
    std::max({FIXED_MAX_CHARS, EXPONENTIAL_MAX_CHARS, PRECISE_MAX_CHARS});

/*
 * Convert a double precision floating point number into its printable
 * form.
 */
bool mozilla::PrintfTarget::cvt_f(double d, char c, int width, int prec,
                                  int flags) {
  bool lower = islower(c);
  const char* inf = lower ? "inf" : "INF";
  const char* nan = lower ? "nan" : "NAN";
  char e = lower ? 'e' : 'E';
  DoubleToStringConverter converter(DTSC::UNIQUE_ZERO | DTSC::NO_TRAILING_ZERO |
                                        DTSC::EMIT_POSITIVE_EXPONENT_SIGN,
                                    inf, nan, e, 0, 0, 4, 0, 2);
  // Longest of the above cases, plus space for a terminal nul character.
  char buf[DTSC_MAX_CHARS + 1];
  double_conversion::StringBuilder builder(buf, sizeof(buf));
  bool success = false;
  if (std::signbit(d)) {
    d = std::abs(d);
    flags |= FLAG_NEG;
  }
  if (!std::isfinite(d)) {
    flags &= ~FLAG_ZEROS;
  }
  // "If the precision is missing, it shall be taken as 6."
  if (prec < 0) {
    prec = 6;
  }
  switch (c) {
    case 'e':
    case 'E':
      success = converter.ToExponential(d, prec, &builder);
      break;
    case 'f':
    case 'F':
      success = converter.ToFixed(d, prec, &builder);
      break;
    case 'g':
    case 'G':
      // "If an explicit precision is zero, it shall be taken as 1."
      success = converter.ToPrecision(d, prec ? prec : 1, &builder);
      break;
  }
  if (!success) {
    return false;
  }
  int len = builder.position();
  char* cvt = builder.Finalize();
  return fill_n(cvt, len, width, prec, TYPE_DOUBLE, flags);
}

/*
 * Convert a string into its printable form.  "width" is the output
 * width. "prec" is the maximum number of characters of "s" to output,
 * where -1 means until NUL.
 */
bool mozilla::PrintfTarget::cvt_s(const char* s, int width, int prec,
                                  int flags) {
  if (prec == 0) {
    return true;
  }
  if (!s) {
    s = "(null)";
  }

  // Limit string length by precision value
  int slen = int(strlen(s));
  if (0 < prec && prec < slen) {
    slen = prec;
  }

  // and away we go
  return fill2(s, slen, width, flags);
}

/*
 * BuildArgArray stands for Numbered Argument list Sprintf
 * for example,
 *      fmp = "%4$i, %2$d, %3s, %1d";
 * the number must start from 1, and no gap among them
 */
static bool BuildArgArray(const char* fmt, va_list ap, NumArgStateVector& nas) {
  size_t number = 0, cn = 0, i;
  const char* p;
  char c;

  // First pass:
  // Detemine how many legal % I have got, then allocate space.

  p = fmt;
  i = 0;
  while ((c = *p++) != 0) {
    if (c != '%') {
      continue;
    }
    if ((c = *p++) == '%') {  // skip %% case
      continue;
    }

    while (c != 0) {
      if (c > '9' || c < '0') {
        if (c == '$') {  // numbered argument case
          if (i > 0) {
            MOZ_CRASH("Bad format string");
          }
          number++;
        } else {  // non-numbered argument case
          if (number > 0) {
            MOZ_CRASH("Bad format string");
          }
          i = 1;
        }
        break;
      }

      c = *p++;
    }
  }

  if (number == 0) {
    return true;
  }

  // Only allow a limited number of arguments.
  MOZ_RELEASE_ASSERT(number <= 20);

  if (!nas.growByUninitialized(number)) {
    return false;
  }

  for (i = 0; i < number; i++) {
    nas[i].type = TYPE_UNKNOWN;
  }

  // Second pass:
  // Set nas[].type.

  p = fmt;
  while ((c = *p++) != 0) {
    if (c != '%') {
      continue;
    }
    c = *p++;
    if (c == '%') {
      continue;
    }

    cn = 0;
    while (c && c != '$') {  // should improve error check later
      cn = cn * 10 + c - '0';
      c = *p++;
    }

    if (!c || cn < 1 || cn > number) {
      MOZ_CRASH("Bad format string");
    }

    // nas[cn] starts from 0, and make sure nas[cn].type is not assigned.
    cn--;
    if (nas[cn].type != TYPE_UNKNOWN) {
      continue;
    }

    c = *p++;

    // flags
    while ((c == '-') || (c == '+') || (c == ' ') || (c == '0')) {
      c = *p++;
    }

    // width
    if (c == '*') {
      // not supported feature, for the argument is not numbered
      MOZ_CRASH("Bad format string");
    }

    while ((c >= '0') && (c <= '9')) {
      c = *p++;
    }

    // precision
    if (c == '.') {
      c = *p++;
      if (c == '*') {
        // not supported feature, for the argument is not numbered
        MOZ_CRASH("Bad format string");
      }

      while ((c >= '0') && (c <= '9')) {
        c = *p++;
      }
    }

    // size
    nas[cn].type = TYPE_INTN;
    if (c == 'h') {
      nas[cn].type = TYPE_SHORT;
      c = *p++;
      if (c == 'h') {
        nas[cn].type = TYPE_SCHAR;
        c = *p++;
      }
    } else if (c == 'L') {
      nas[cn].type = TYPE_LONGLONG;
      c = *p++;
    } else if (c == 'l') {
      nas[cn].type = TYPE_LONG;
      c = *p++;
      if (c == 'l') {
        nas[cn].type = TYPE_LONGLONG;
        c = *p++;
      }
    } else if (c == 'z' || c == 'I') {
      static_assert(sizeof(size_t) == sizeof(int) ||
                        sizeof(size_t) == sizeof(long) ||
                        sizeof(size_t) == sizeof(long long),
                    "size_t is not one of the expected sizes");
      nas[cn].type = sizeof(size_t) == sizeof(int)    ? TYPE_INTN
                     : sizeof(size_t) == sizeof(long) ? TYPE_LONG
                                                      : TYPE_LONGLONG;
      c = *p++;
    } else if (c == 't') {
      static_assert(sizeof(ptrdiff_t) == sizeof(int) ||
                        sizeof(ptrdiff_t) == sizeof(long) ||
                        sizeof(ptrdiff_t) == sizeof(long long),
                    "ptrdiff_t is not one of the expected sizes");
      nas[cn].type = sizeof(ptrdiff_t) == sizeof(int)    ? TYPE_INTN
                     : sizeof(ptrdiff_t) == sizeof(long) ? TYPE_LONG
                                                         : TYPE_LONGLONG;
      c = *p++;
    } else if (c == 'j') {
      static_assert(sizeof(intmax_t) == sizeof(int) ||
                        sizeof(intmax_t) == sizeof(long) ||
                        sizeof(intmax_t) == sizeof(long long),
                    "intmax_t is not one of the expected sizes");
      nas[cn].type = sizeof(intmax_t) == sizeof(int)    ? TYPE_INTN
                     : sizeof(intmax_t) == sizeof(long) ? TYPE_LONG
                                                        : TYPE_LONGLONG;
      c = *p++;
    }

    // format
    switch (c) {
      case 'd':
      case 'c':
      case 'i':
        break;

      case 'o':
      case 'u':
      case 'x':
      case 'X':
        // Mark as unsigned type.
        nas[cn].type |= 1;
        break;

      case 'e':
      case 'E':
      case 'f':
      case 'F':
      case 'g':
      case 'G':
        nas[cn].type = TYPE_DOUBLE;
        break;

      case 'p':
        nas[cn].type = TYPE_POINTER;
        break;

      case 'S':
#if defined(XP_WIN)
        nas[cn].type = TYPE_WSTRING;
#else
        MOZ_ASSERT(0);
        nas[cn].type = TYPE_UNKNOWN;
#endif
        break;

      case 's':
#if defined(XP_WIN)
        if (nas[cn].type == TYPE_LONG) {
          nas[cn].type = TYPE_WSTRING;
          break;
        }
#endif
        // Other type sizes are not supported here.
        MOZ_ASSERT(nas[cn].type == TYPE_INTN);
        nas[cn].type = TYPE_STRING;
        break;

      case 'n':
        nas[cn].type = TYPE_INTSTR;
        break;

      default:
        MOZ_ASSERT(0);
        nas[cn].type = TYPE_UNKNOWN;
        break;
    }

    // get a legal para.
    if (nas[cn].type == TYPE_UNKNOWN) {
      MOZ_CRASH("Bad format string");
    }
  }

  // Third pass:
  // Fill nas[].ap.

  cn = 0;
  while (cn < number) {
    // A TYPE_UNKNOWN here means that the format asked for a
    // positional argument without specifying the meaning of some
    // earlier argument.
    MOZ_ASSERT(nas[cn].type != TYPE_UNKNOWN);

    VARARGS_ASSIGN(nas[cn].ap, ap);

    switch (nas[cn].type) {
      case TYPE_SCHAR:
      case TYPE_UCHAR:
      case TYPE_SHORT:
      case TYPE_USHORT:
      case TYPE_INTN:
      case TYPE_UINTN:
        (void)va_arg(ap, int);
        break;
      case TYPE_LONG:
        (void)va_arg(ap, long);
        break;
      case TYPE_ULONG:
        (void)va_arg(ap, unsigned long);
        break;
      case TYPE_LONGLONG:
        (void)va_arg(ap, long long);
        break;
      case TYPE_ULONGLONG:
        (void)va_arg(ap, unsigned long long);
        break;
      case TYPE_STRING:
        (void)va_arg(ap, char*);
        break;
      case TYPE_INTSTR:
        (void)va_arg(ap, int*);
        break;
      case TYPE_DOUBLE:
        (void)va_arg(ap, double);
        break;
      case TYPE_POINTER:
        (void)va_arg(ap, void*);
        break;
#if defined(XP_WIN)
      case TYPE_WSTRING:
        (void)va_arg(ap, wchar_t*);
        break;
#endif

      default:
        MOZ_CRASH();
    }

    cn++;
  }

  return true;
}

mozilla::PrintfTarget::PrintfTarget() : mEmitted(0) {}

bool mozilla::PrintfTarget::vprint(const char* fmt, va_list ap) {
  char c;
  int flags, width, prec, radix, type;
  union {
    char ch;
    int i;
    long l;
    long long ll;
    double d;
    const char* s;
    int* ip;
    void* p;
#if defined(XP_WIN)
    const wchar_t* ws;
#endif
  } u{};
  const char* hexp;
  int i;

  // Build an argument array, IF the fmt is numbered argument
  // list style, to contain the Numbered Argument list pointers.

  NumArgStateVector nas;
  if (!BuildArgArray(fmt, ap, nas)) {
    // the fmt contains error Numbered Argument format, jliu@netscape.com
    MOZ_CRASH("Bad format string");
  }

  while ((c = *fmt++) != 0) {
    if (c != '%') {
      if (!emit(fmt - 1, 1)) {
        return false;
      }

      continue;
    }

    // Gobble up the % format string. Hopefully we have handled all
    // of the strange cases!
    flags = 0;
    c = *fmt++;
    if (c == '%') {
      // quoting a % with %%
      if (!emit(fmt - 1, 1)) {
        return false;
      }

      continue;
    }

    if (!nas.empty()) {
      // the fmt contains the Numbered Arguments feature
      i = 0;
      while (c && c != '$') {  // should improve error check later
        i = (i * 10) + (c - '0');
        c = *fmt++;
      }

      if (nas[i - 1].type == TYPE_UNKNOWN) {
        MOZ_CRASH("Bad format string");
      }

      ap = nas[i - 1].ap;
      c = *fmt++;
    }

    // Examine optional flags.  Note that we do not implement the
    // '#' flag of sprintf().  The ANSI C spec. of the '#' flag is
    // somewhat ambiguous and not ideal, which is perhaps why
    // the various sprintf() implementations are inconsistent
    // on this feature.
    while ((c == '-') || (c == '+') || (c == ' ') || (c == '0')) {
      if (c == '-') {
        flags |= FLAG_LEFT;
      }
      if (c == '+') {
        flags |= FLAG_SIGNED;
      }
      if (c == ' ') {
        flags |= FLAG_SPACED;
      }
      if (c == '0') {
        flags |= FLAG_ZEROS;
      }
      c = *fmt++;
    }
    if (flags & FLAG_SIGNED) {
      flags &= ~FLAG_SPACED;
    }
    if (flags & FLAG_LEFT) {
      flags &= ~FLAG_ZEROS;
    }

    // width
    if (c == '*') {
      c = *fmt++;
      width = va_arg(ap, int);
      if (width < 0) {
        width = -width;
        flags |= FLAG_LEFT;
        flags &= ~FLAG_ZEROS;
      }
    } else {
      width = 0;
      while ((c >= '0') && (c <= '9')) {
        width = (width * 10) + (c - '0');
        c = *fmt++;
      }
    }

    // precision
    prec = -1;
    if (c == '.') {
      c = *fmt++;
      if (c == '*') {
        c = *fmt++;
        prec = va_arg(ap, int);
      } else {
        prec = 0;
        while ((c >= '0') && (c <= '9')) {
          prec = (prec * 10) + (c - '0');
          c = *fmt++;
        }
      }
    }

    // size
    type = TYPE_INTN;
    if (c == 'h') {
      type = TYPE_SHORT;
      c = *fmt++;
      if (c == 'h') {
        type = TYPE_SCHAR;
        c = *fmt++;
      }
    } else if (c == 'L') {
      type = TYPE_LONGLONG;
      c = *fmt++;
    } else if (c == 'l') {
      type = TYPE_LONG;
      c = *fmt++;
      if (c == 'l') {
        type = TYPE_LONGLONG;
        c = *fmt++;
      }
    } else if (c == 'z' || c == 'I') {
      static_assert(sizeof(size_t) == sizeof(int) ||
                        sizeof(size_t) == sizeof(long) ||
                        sizeof(size_t) == sizeof(long long),
                    "size_t is not one of the expected sizes");
      type = sizeof(size_t) == sizeof(int)    ? TYPE_INTN
             : sizeof(size_t) == sizeof(long) ? TYPE_LONG
                                              : TYPE_LONGLONG;
      c = *fmt++;
    } else if (c == 't') {
      static_assert(sizeof(ptrdiff_t) == sizeof(int) ||
                        sizeof(ptrdiff_t) == sizeof(long) ||
                        sizeof(ptrdiff_t) == sizeof(long long),
                    "ptrdiff_t is not one of the expected sizes");
      type = sizeof(ptrdiff_t) == sizeof(int)    ? TYPE_INTN
             : sizeof(ptrdiff_t) == sizeof(long) ? TYPE_LONG
                                                 : TYPE_LONGLONG;
      c = *fmt++;
    } else if (c == 'j') {
      static_assert(sizeof(intmax_t) == sizeof(int) ||
                        sizeof(intmax_t) == sizeof(long) ||
                        sizeof(intmax_t) == sizeof(long long),
                    "intmax_t is not one of the expected sizes");
      type = sizeof(intmax_t) == sizeof(int)    ? TYPE_INTN
             : sizeof(intmax_t) == sizeof(long) ? TYPE_LONG
                                                : TYPE_LONGLONG;
      c = *fmt++;
    }

    // format
    hexp = hex;
    switch (c) {
      case 'd':
      case 'i':  // decimal/integer
        radix = 10;
        goto fetch_and_convert;

      case 'o':  // octal
        radix = 8;
        type |= 1;
        goto fetch_and_convert;

      case 'u':  // unsigned decimal
        radix = 10;
        type |= 1;
        goto fetch_and_convert;

      case 'x':  // unsigned hex
        radix = 16;
        type |= 1;
        goto fetch_and_convert;

      case 'X':  // unsigned HEX
        radix = 16;
        hexp = HEX;
        type |= 1;
        goto fetch_and_convert;

      fetch_and_convert:
        switch (type) {
          case TYPE_SCHAR:
            u.l = (signed char)va_arg(ap, int);
            if (u.l < 0) {
              u.l = -u.l;
              flags |= FLAG_NEG;
            }
            goto do_long;
          case TYPE_UCHAR:
            u.l = (unsigned char)va_arg(ap, unsigned int);
            goto do_long;
          case TYPE_SHORT:
            u.l = (short)va_arg(ap, int);
            if (u.l < 0) {
              u.l = -u.l;
              flags |= FLAG_NEG;
            }
            goto do_long;
          case TYPE_USHORT:
            u.l = (unsigned short)va_arg(ap, unsigned int);
            goto do_long;
          case TYPE_INTN:
            u.l = va_arg(ap, int);
            if (u.l < 0) {
              u.l = -u.l;
              flags |= FLAG_NEG;
            }
            goto do_long;
          case TYPE_UINTN:
            u.l = (long)va_arg(ap, unsigned int);
            goto do_long;

          case TYPE_LONG:
            u.l = va_arg(ap, long);
            if (u.l < 0) {
              u.l = -u.l;
              flags |= FLAG_NEG;
            }
            goto do_long;
          case TYPE_ULONG:
            u.l = (long)va_arg(ap, unsigned long);
          do_long:
            if (!cvt_l(u.l, width, prec, radix, type, flags, hexp)) {
              return false;
            }

            break;

          case TYPE_LONGLONG:
            u.ll = va_arg(ap, long long);
            if (u.ll < 0) {
              u.ll = -u.ll;
              flags |= FLAG_NEG;
            }
            goto do_longlong;
          case TYPE_POINTER:
            u.ll = (uintptr_t)va_arg(ap, void*);
            goto do_longlong;
          case TYPE_ULONGLONG:
            u.ll = va_arg(ap, unsigned long long);
          do_longlong:
            if (!cvt_ll(u.ll, width, prec, radix, type, flags, hexp)) {
              return false;
            }

            break;
        }
        break;

      case 'e':
      case 'E':
      case 'f':
      case 'F':
      case 'g':
      case 'G':
        u.d = va_arg(ap, double);
        if (!cvt_f(u.d, c, width, prec, flags)) {
          return false;
        }

        break;

      case 'c':
        if ((flags & FLAG_LEFT) == 0) {
          while (width-- > 1) {
            if (!emit(" ", 1)) {
              return false;
            }
          }
        }
        switch (type) {
          case TYPE_SHORT:
          case TYPE_INTN:
            u.ch = va_arg(ap, int);
            if (!emit(&u.ch, 1)) {
              return false;
            }
            break;
        }
        if (flags & FLAG_LEFT) {
          while (width-- > 1) {
            if (!emit(" ", 1)) {
              return false;
            }
          }
        }
        break;

      case 'p':
        type = TYPE_POINTER;
        radix = 16;
        goto fetch_and_convert;

      case 's':
        if (type == TYPE_INTN) {
          u.s = va_arg(ap, const char*);
          if (!cvt_s(u.s, width, prec, flags)) {
            return false;
          }
          break;
        }
        MOZ_ASSERT(type == TYPE_LONG);
        [[fallthrough]];
      case 'S':
#if defined(XP_WIN)
      {
        u.ws = va_arg(ap, const wchar_t*);

        int rv = WideCharToMultiByte(CP_ACP, 0, u.ws, -1, NULL, 0, NULL, NULL);
        if (rv == 0 && GetLastError() == ERROR_NO_UNICODE_TRANSLATION) {
          if (!cvt_s("<unicode errors in string>", width, prec, flags)) {
            return false;
          }
        } else {
          if (rv == 0) {
            rv = 1;
          }
          UniqueFreePtr<char[]> buf((char*)malloc(rv));
          WideCharToMultiByte(CP_ACP, 0, u.ws, -1, buf.get(), rv, NULL, NULL);
          buf[rv - 1] = '\0';

          if (!cvt_s(buf.get(), width, prec, flags)) {
            return false;
          }
        }
      }
#else
        // Not supported here.
        MOZ_ASSERT(0);
#endif
      break;

      case 'n':
        u.ip = va_arg(ap, int*);
        if (u.ip) {
          *u.ip = mEmitted;
        }
        break;

      default:
        // Not a % token after all... skip it
        if (!emit("%", 1)) {
          return false;
        }
        if (!emit(fmt - 1, 1)) {
          return false;
        }
    }
  }

  return true;
}

/************************************************************************/

bool mozilla::PrintfTarget::print(const char* format, ...) {
  va_list ap;

  va_start(ap, format);
  bool result = vprint(format, ap);
  va_end(ap);
  return result;
}

#undef TYPE_SHORT
#undef TYPE_USHORT
#undef TYPE_INTN
#undef TYPE_UINTN
#undef TYPE_LONG
#undef TYPE_ULONG
#undef TYPE_LONGLONG
#undef TYPE_ULONGLONG
#undef TYPE_STRING
#undef TYPE_DOUBLE
#undef TYPE_INTSTR
#undef TYPE_POINTER
#undef TYPE_WSTRING
#undef TYPE_UNKNOWN
#undef TYPE_SCHAR
#undef TYPE_UCHAR

#undef FLAG_LEFT
#undef FLAG_SIGNED
#undef FLAG_SPACED
#undef FLAG_ZEROS
#undef FLAG_NEG