gecko-dev/xpcom/glue/nsTextFormatter.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.
 *
 * Code based on mozilla/nsprpub/src/io/prprf.c rev 3.7
 *
 * Contributor(s):
 *   Kipp E.B. Hickman  <kipp@netscape.com>  (original author)
 *   Frank Yung-Fong Tang  <ftang@netscape.com>
 *   Daniele Nicolodi  <daniele@grinta.net>
 */

/*
 * Copied from xpcom/ds/nsTextFormatter.cpp r1.22
 *     Changed to use nsMemory and Frozen linkage
 *                  -- Prasad <prasad@medhas.org>
 */

#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include "prdtoa.h"
#include "mozilla/Logging.h"
#include "mozilla/Snprintf.h"
#include "prmem.h"
#include "nsCRTGlue.h"
#include "nsTextFormatter.h"
#include "nsMemory.h"

/*
** 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

typedef struct SprintfStateStr SprintfState;

struct SprintfStateStr
{
  int (*stuff)(SprintfState* aState, const char16_t* aStr, uint32_t aLen);

  char16_t* base;
  char16_t* cur;
  uint32_t maxlen;

  void* stuffclosure;
};

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

  enum Type
  {
    INT16,
    UINT16,
    INTN,
    UINTN,
    INT32,
    UINT32,
    INT64,
    UINT64,
    STRING,
    DOUBLE,
    INTSTR,
    UNISTRING,
    UNKNOWN
  };
};

#define NAS_DEFAULT_NUM 20  /* default number of NumberedArgumentState array */

#define _LEFT		0x1
#define _SIGNED		0x2
#define _SPACED		0x4
#define _ZEROS		0x8
#define _NEG		0x10

#define ELEMENTS_OF(array_) (sizeof(array_) / sizeof(array_[0]))

/*
** Fill into the buffer using the data in src
*/
static int
fill2(SprintfState* aState, const char16_t* aSrc, int aSrcLen, int aWidth,
      int aFlags)
{
  char16_t space = ' ';
  int rv;

  aWidth -= aSrcLen;
  /* Right adjusting */
  if ((aWidth > 0) && ((aFlags & _LEFT) == 0)) {
    if (aFlags & _ZEROS) {
      space = '0';
    }
    while (--aWidth >= 0) {
      rv = (*aState->stuff)(aState, &space, 1);
      if (rv < 0) {
        return rv;
      }
    }
  }

  /* Copy out the source data */
  rv = (*aState->stuff)(aState, aSrc, aSrcLen);
  if (rv < 0) {
    return rv;
  }

  /* Left adjusting */
  if ((aWidth > 0) && ((aFlags & _LEFT) != 0)) {
    while (--aWidth >= 0) {
      rv = (*aState->stuff)(aState, &space, 1);
      if (rv < 0) {
        return rv;
      }
    }
  }
  return 0;
}

/*
** Fill a number. The order is: optional-sign zero-filling conversion-digits
*/
static int
fill_n(SprintfState* aState, const char16_t* aSrc, int aSrcLen, int aWidth,
       int aPrec, int aType, int aFlags)
{
  int zerowidth   = 0;
  int precwidth   = 0;
  int signwidth   = 0;
  int leftspaces  = 0;
  int rightspaces = 0;
  int cvtwidth;
  int rv;
  char16_t sign;
  char16_t space = ' ';
  char16_t zero = '0';

  if ((aType & 1) == 0) {
    if (aFlags & _NEG) {
      sign = '-';
      signwidth = 1;
    } else if (aFlags & _SIGNED) {
      sign = '+';
      signwidth = 1;
    } else if (aFlags & _SPACED) {
      sign = ' ';
      signwidth = 1;
    }
  }
  cvtwidth = signwidth + aSrcLen;

  if (aPrec > 0) {
    if (aPrec > aSrcLen) {
      /* Need zero filling */
      precwidth = aPrec - aSrcLen;
      cvtwidth += precwidth;
    }
  }

  if ((aFlags & _ZEROS) && (aPrec < 0)) {
    if (aWidth > cvtwidth) {
      /* Zero filling */
      zerowidth = aWidth - cvtwidth;
      cvtwidth += zerowidth;
    }
  }

  if (aFlags & _LEFT) {
    if (aWidth > cvtwidth) {
      /* Space filling on the right (i.e. left adjusting) */
      rightspaces = aWidth - cvtwidth;
    }
  } else {
    if (aWidth > cvtwidth) {
      /* Space filling on the left (i.e. right adjusting) */
      leftspaces = aWidth - cvtwidth;
    }
  }
  while (--leftspaces >= 0) {
    rv = (*aState->stuff)(aState, &space, 1);
    if (rv < 0) {
      return rv;
    }
  }
  if (signwidth) {
    rv = (*aState->stuff)(aState, &sign, 1);
    if (rv < 0) {
      return rv;
    }
  }
  while (--precwidth >= 0) {
    rv = (*aState->stuff)(aState,  &space, 1);
    if (rv < 0) {
      return rv;
    }
  }
  while (--zerowidth >= 0) {
    rv = (*aState->stuff)(aState,  &zero, 1);
    if (rv < 0) {
      return rv;
    }
  }
  rv = (*aState->stuff)(aState, aSrc, aSrcLen);
  if (rv < 0) {
    return rv;
  }
  while (--rightspaces >= 0) {
    rv = (*aState->stuff)(aState,  &space, 1);
    if (rv < 0) {
      return rv;
    }
  }
  return 0;
}

/*
** Convert a long into its printable form
*/
static int
cvt_l(SprintfState* aState, long aNum, int aWidth, int aPrec, int aRadix,
      int aType, int aFlags, const char16_t* aHexStr)
{
  char16_t cvtbuf[100];
  char16_t* cvt;
  int digits;

  /* according to the man page this needs to happen */
  if ((aPrec == 0) && (aNum == 0)) {
    return 0;
  }

  /*
  ** 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[0] + ELEMENTS_OF(cvtbuf);
  digits = 0;
  while (aNum) {
    int digit = (((unsigned long)aNum) % aRadix) & 0xF;
    *--cvt = aHexStr[digit];
    digits++;
    aNum = (long)(((unsigned long)aNum) / aRadix);
  }
  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(aState, cvt, digits, aWidth, aPrec, aType, aFlags);
}

/*
** Convert a 64-bit integer into its printable form
*/
static int
cvt_ll(SprintfState* aState, int64_t aNum, int aWidth, int aPrec, int aRadix,
       int aType, int aFlags, const char16_t* aHexStr)
{
  char16_t cvtbuf[100];
  char16_t* cvt;
  int digits;
  int64_t rad;

  /* according to the man page this needs to happen */
  if (aPrec == 0 && aNum == 0) {
    return 0;
  }

  /*
  ** 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.
  */
  rad = aRadix;
  cvt = &cvtbuf[0] + ELEMENTS_OF(cvtbuf);
  digits = 0;
  while (aNum != 0) {
    *--cvt = aHexStr[int32_t(aNum % rad) & 0xf];
    digits++;
    aNum /= rad;
  }
  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(aState, cvt, digits, aWidth, aPrec, aType, aFlags);
}

/*
** Convert a double precision floating point number into its printable
** form.
*/
static int
cvt_f(SprintfState* aState, double aDouble, int aWidth, int aPrec,
      const char16_t aType, int aFlags)
{
  int    mode = 2;
  int    decpt;
  int    sign;
  char   buf[256];
  char*  bufp = buf;
  int    bufsz = 256;
  char   num[256];
  char*  nump;
  char*  endnum;
  int    numdigits = 0;
  char   exp = 'e';

  if (aPrec == -1) {
    aPrec = 6;
  } else if (aPrec > 50) {
    // limit precision to avoid PR_dtoa bug 108335
    // and to prevent buffers overflows
    aPrec = 50;
  }

  switch (aType) {
    case 'f':
      numdigits = aPrec;
      mode = 3;
      break;
    case 'E':
      exp = 'E';
      MOZ_FALLTHROUGH;
    case 'e':
      numdigits = aPrec + 1;
      mode = 2;
      break;
    case 'G':
      exp = 'E';
      MOZ_FALLTHROUGH;
    case 'g':
      if (aPrec == 0) {
        aPrec = 1;
      }
      numdigits = aPrec;
      mode = 2;
      break;
    default:
      NS_ERROR("invalid aType passed to cvt_f");
  }

  if (PR_dtoa(aDouble, mode, numdigits, &decpt, &sign,
              &endnum, num, bufsz) == PR_FAILURE) {
    buf[0] = '\0';
    return -1;
  }
  numdigits = endnum - num;
  nump = num;

  if (sign) {
    *bufp++ = '-';
  } else if (aFlags & _SIGNED) {
    *bufp++ = '+';
  }

  if (decpt == 9999) {
    while ((*bufp++ = *nump++)) {
    }
  } else {

    switch (aType) {

      case 'E':
      case 'e':

        *bufp++ = *nump++;
        if (aPrec > 0) {
          *bufp++ = '.';
          while (*nump) {
            *bufp++ = *nump++;
            aPrec--;
          }
          while (aPrec-- > 0) {
            *bufp++ = '0';
          }
        }
        *bufp++ = exp;

        snprintf(bufp, bufsz - (bufp - buf), "%+03d", decpt - 1);
        break;

      case 'f':

        if (decpt < 1) {
          *bufp++ = '0';
          if (aPrec > 0) {
            *bufp++ = '.';
            while (decpt++ && aPrec-- > 0) {
              *bufp++ = '0';
            }
            while (*nump && aPrec-- > 0) {
              *bufp++ = *nump++;
            }
            while (aPrec-- > 0) {
              *bufp++ = '0';
            }
          }
        } else {
          while (*nump && decpt-- > 0) {
            *bufp++ = *nump++;
          }
          while (decpt-- > 0) {
            *bufp++ = '0';
          }
          if (aPrec > 0) {
            *bufp++ = '.';
            while (*nump && aPrec-- > 0) {
              *bufp++ = *nump++;
            }
            while (aPrec-- > 0) {
              *bufp++ = '0';
            }
          }
        }
        *bufp = '\0';
        break;

      case 'G':
      case 'g':

        if ((decpt < -3) || ((decpt - 1) >= aPrec)) {
          *bufp++ = *nump++;
          numdigits--;
          if (numdigits > 0) {
            *bufp++ = '.';
            while (*nump) {
              *bufp++ = *nump++;
            }
          }
          *bufp++ = exp;
          snprintf(bufp, bufsz - (bufp - buf), "%+03d", decpt - 1);
        } else {
          if (decpt < 1) {
            *bufp++ = '0';
            if (aPrec > 0) {
              *bufp++ = '.';
              while (decpt++) {
                *bufp++ = '0';
              }
              while (*nump) {
                *bufp++ = *nump++;
              }
            }
          } else {
            while (*nump && decpt-- > 0) {
              *bufp++ = *nump++;
              numdigits--;
            }
            while (decpt-- > 0) {
              *bufp++ = '0';
            }
            if (numdigits > 0) {
              *bufp++ = '.';
              while (*nump) {
                *bufp++ = *nump++;
              }
            }
          }
          *bufp = '\0';
        }
    }
  }

  char16_t rbuf[256];
  char16_t* rbufp = rbuf;
  bufp = buf;
  // cast to char16_t
  while ((*rbufp++ = *bufp++)) {
  }
  *rbufp = '\0';

  return fill2(aState, rbuf, NS_strlen(rbuf), aWidth, aFlags);
}

/*
** Convert a string into its printable form. |aWidth| is the output
** width. |aPrec| is the maximum number of characters of |aStr| to output,
** where -1 means until NUL.
*/
static int
cvt_S(SprintfState* aState, const char16_t* aStr, int aWidth, int aPrec,
      int aFlags)
{
  int slen;

  if (aPrec == 0) {
    return 0;
  }

  /* Limit string length by precision value */
  slen = aStr ? NS_strlen(aStr) : 6;
  if (aPrec > 0) {
    if (aPrec < slen) {
      slen = aPrec;
    }
  }

  /* and away we go */
  return fill2(aState, aStr ? aStr : MOZ_UTF16("(null)"), slen, aWidth, aFlags);
}

/*
** Convert a string into its printable form.  |aWidth| is the output
** width. |aPrec| is the maximum number of characters of |aStr| to output,
** where -1 means until NUL.
*/
static int
cvt_s(SprintfState* aState, const char* aStr, int aWidth, int aPrec, int aFlags)
{
  NS_ConvertUTF8toUTF16 utf16Val(aStr);
  return cvt_S(aState, utf16Val.get(), aWidth, aPrec, aFlags);
}

/*
** 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 struct NumArgState*
BuildArgArray(const char16_t* aFmt, va_list aAp, int* aRv,
              struct NumArgState* aNasArray)
{
  int number = 0, cn = 0, i;
  const char16_t* p;
  char16_t  c;
  struct NumArgState* nas;

  /*
  **	first pass:
  **	detemine how many legal % I have got, then allocate space
  */
  p = aFmt;
  *aRv = 0;
  i = 0;
  while ((c = *p++) != 0) {
    if (c != '%') {
      continue;
    }
    /* skip %% case */
    if ((c = *p++) == '%') {
      continue;
    }

    while (c != 0) {
      if (c > '9' || c < '0') {
        /* numbered argument csae */
        if (c == '$') {
          if (i > 0) {
            *aRv = -1;
            return nullptr;
          }
          number++;
          break;

        } else {
          /* non-numbered argument case */
          if (number > 0) {
            *aRv = -1;
            return nullptr;
          }
          i = 1;
          break;
        }
      }
      c = *p++;
    }
  }

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

  if (number > NAS_DEFAULT_NUM) {
    nas = (struct NumArgState*)moz_xmalloc(number * sizeof(struct NumArgState));
    if (!nas) {
      *aRv = -1;
      return nullptr;
    }
  } else {
    nas = aNasArray;
  }

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

  /*
  ** second pass:
  ** set nas[].type
  */
  p = aFmt;
  while ((c = *p++) != 0) {
    if (c != '%') {
      continue;
    }
    c = *p++;
    if (c == '%') {
      continue;
    }
    cn = 0;
    /* should imporve error check later */
    while (c && c != '$') {
      cn = cn * 10 + c - '0';
      c = *p++;
    }

    if (!c || cn < 1 || cn > number) {
      *aRv = -1;
      break;
    }

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

    c = *p++;

    /* width */
    if (c == '*') {
      /* not supported feature, for the argument is not numbered */
      *aRv = -1;
      break;
    } else {
      while ((c >= '0') && (c <= '9')) {
        c = *p++;
      }
    }

    /* precision */
    if (c == '.') {
      c = *p++;
      if (c == '*') {
        /* not supported feature, for the argument is not numbered */
        *aRv = -1;
        break;
      } else {
        while ((c >= '0') && (c <= '9')) {
          c = *p++;
        }
      }
    }

    /* size */
    nas[cn].type = NumArgState::INTN;
    if (c == 'h') {
      nas[cn].type = NumArgState::INT16;
      c = *p++;
    } else if (c == 'L') {
      /* XXX not quite sure here */
      nas[cn].type = NumArgState::INT64;
      c = *p++;
    } else if (c == 'l') {
      nas[cn].type = NumArgState::INT32;
      c = *p++;
      if (c == 'l') {
        nas[cn].type = NumArgState::INT64;
        c = *p++;
      }
    }

    /* format */
    switch (c) {
      case 'd':
      case 'c':
      case 'i':
      case 'o':
      case 'u':
      case 'x':
      case 'X':
        break;

      case 'e':
      case 'f':
      case 'g':
        nas[cn].type = NumArgState::DOUBLE;
        break;

      case 'p':
        /* XXX should use cpp */
        if (sizeof(void*) == sizeof(int32_t)) {
          nas[cn].type = NumArgState::UINT32;
        } else if (sizeof(void*) == sizeof(int64_t)) {
          nas[cn].type = NumArgState::UINT64;
        } else if (sizeof(void*) == sizeof(int)) {
          nas[cn].type = NumArgState::UINTN;
        } else {
          nas[cn].type = NumArgState::UNKNOWN;
        }
        break;

      case 'C':
        /* XXX not supported I suppose */
        PR_ASSERT(0);
        nas[cn].type = NumArgState::UNKNOWN;
        break;

      case 'S':
        nas[cn].type = NumArgState::UNISTRING;
        break;

      case 's':
        nas[cn].type = NumArgState::STRING;
        break;

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

      default:
        PR_ASSERT(0);
        nas[cn].type = NumArgState::UNKNOWN;
        break;
    }

    /* get a legal para. */
    if (nas[cn].type == NumArgState::UNKNOWN) {
      *aRv = -1;
      break;
    }
  }


  /*
  ** third pass
  ** fill the nas[cn].ap
  */
  if (*aRv < 0) {
    if (nas != aNasArray) {
      PR_DELETE(nas);
    }
    return nullptr;
  }

  cn = 0;
  while (cn < number) {
    if (nas[cn].type == NumArgState::UNKNOWN) {
      cn++;
      continue;
    }

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

    switch (nas[cn].type) {
      case NumArgState::INT16:
      case NumArgState::UINT16:
      case NumArgState::INTN:
      case NumArgState::UINTN:     (void)va_arg(aAp, int);         break;

      case NumArgState::INT32:     (void)va_arg(aAp, int32_t);     break;

      case NumArgState::UINT32:    (void)va_arg(aAp, uint32_t);    break;

      case NumArgState::INT64:     (void)va_arg(aAp, int64_t);     break;

      case NumArgState::UINT64:    (void)va_arg(aAp, uint64_t);    break;

      case NumArgState::STRING:    (void)va_arg(aAp, char*);       break;

      case NumArgState::INTSTR:    (void)va_arg(aAp, int*);        break;

      case NumArgState::DOUBLE:    (void)va_arg(aAp, double);      break;

      case NumArgState::UNISTRING: (void)va_arg(aAp, char16_t*);   break;

      default:
        if (nas != aNasArray) {
          PR_DELETE(nas);
        }
        *aRv = -1;
        return nullptr;
    }
    cn++;
  }
  return nas;
}

/*
** The workhorse sprintf code.
*/
static int
dosprintf(SprintfState* aState, const char16_t* aFmt, va_list aAp)
{
  char16_t c;
  int flags, width, prec, radix, type;
  union
  {
    char16_t ch;
    int i;
    long l;
    int64_t ll;
    double d;
    const char* s;
    const char16_t* S;
    int* ip;
  } u;
  char16_t space = ' ';

  nsAutoString hex;
  hex.AssignLiteral("0123456789abcdef");

  nsAutoString HEX;
  HEX.AssignLiteral("0123456789ABCDEF");

  const char16_t* hexp;
  int rv, i;
  struct NumArgState* nas = nullptr;
  struct NumArgState  nasArray[NAS_DEFAULT_NUM];


  /*
  ** build an argument array, IF the aFmt is numbered argument
  ** list style, to contain the Numbered Argument list pointers
  */
  nas = BuildArgArray(aFmt, aAp, &rv, nasArray);
  if (rv < 0) {
    /* the aFmt contains error Numbered Argument format, jliu@netscape.com */
    PR_ASSERT(0);
    return rv;
  }

  while ((c = *aFmt++) != 0) {
    if (c != '%') {
      rv = (*aState->stuff)(aState, aFmt - 1, 1);
      if (rv < 0) {
        return rv;
      }
      continue;
    }

    /*
    ** Gobble up the % format string. Hopefully we have handled all
    ** of the strange cases!
    */
    flags = 0;
    c = *aFmt++;
    if (c == '%') {
      /* quoting a % with %% */
      rv = (*aState->stuff)(aState, aFmt - 1, 1);
      if (rv < 0) {
        return rv;
      }
      continue;
    }

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

      if (nas[i - 1].type == NumArgState::UNKNOWN) {
        if (nas && (nas != nasArray)) {
          PR_DELETE(nas);
        }
        return -1;
      }

      VARARGS_ASSIGN(aAp, nas[i - 1].ap);
      c = *aFmt++;
    }

    /*
     * 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 |= _LEFT;
      }
      if (c == '+') {
        flags |= _SIGNED;
      }
      if (c == ' ') {
        flags |= _SPACED;
      }
      if (c == '0') {
        flags |= _ZEROS;
      }
      c = *aFmt++;
    }
    if (flags & _SIGNED) {
      flags &= ~_SPACED;
    }
    if (flags & _LEFT) {
      flags &= ~_ZEROS;
    }

    /* width */
    if (c == '*') {
      c = *aFmt++;
      width = va_arg(aAp, int);
    } else {
      width = 0;
      while ((c >= '0') && (c <= '9')) {
        width = (width * 10) + (c - '0');
        c = *aFmt++;
      }
    }

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

    /* size */
    type = NumArgState::INTN;
    if (c == 'h') {
      type = NumArgState::INT16;
      c = *aFmt++;
    } else if (c == 'L') {
      /* XXX not quite sure here */
      type = NumArgState::INT64;
      c = *aFmt++;
    } else if (c == 'l') {
      type = NumArgState::INT32;
      c = *aFmt++;
      if (c == 'l') {
        type = NumArgState::INT64;
        c = *aFmt++;
      }
    }

    /* format */
    hexp = hex.get();
    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.get();
        type |= 1;
        goto fetch_and_convert;

        fetch_and_convert:
        switch (type) {
          case NumArgState::INT16:
            u.l = va_arg(aAp, int);
            if (u.l < 0) {
              u.l = -u.l;
              flags |= _NEG;
            }
            goto do_long;
          case NumArgState::UINT16:
            u.l = va_arg(aAp, int) & 0xffff;
            goto do_long;
          case NumArgState::INTN:
            u.l = va_arg(aAp, int);
            if (u.l < 0) {
              u.l = -u.l;
              flags |= _NEG;
            }
            goto do_long;
          case NumArgState::UINTN:
            u.l = (long)va_arg(aAp, unsigned int);
            goto do_long;

          case NumArgState::INT32:
            u.l = va_arg(aAp, int32_t);
            if (u.l < 0) {
              u.l = -u.l;
              flags |= _NEG;
            }
            goto do_long;
          case NumArgState::UINT32:
            u.l = (long)va_arg(aAp, uint32_t);
          do_long:
            rv = cvt_l(aState, u.l, width, prec, radix, type, flags, hexp);
            if (rv < 0) {
              return rv;
            }
            break;

          case NumArgState::INT64:
            u.ll = va_arg(aAp, int64_t);
            if (u.ll < 0) {
              u.ll = -u.ll;
              flags |= _NEG;
            }
            goto do_longlong;
          case NumArgState::UINT64:
            u.ll = va_arg(aAp, uint64_t);
          do_longlong:
            rv = cvt_ll(aState, u.ll, width, prec, radix, type, flags, hexp);
            if (rv < 0) {
              return rv;
            }
            break;
        }
        break;

      case 'e':
      case 'E':
      case 'f':
      case 'g':
      case 'G':
        u.d = va_arg(aAp, double);
        rv = cvt_f(aState, u.d, width, prec, c, flags);
        if (rv < 0) {
          return rv;
        }
        break;

      case 'c':
        u.ch = va_arg(aAp, int);
        if ((flags & _LEFT) == 0) {
          while (width-- > 1) {
            rv = (*aState->stuff)(aState, &space, 1);
            if (rv < 0) {
              return rv;
            }
          }
        }
        rv = (*aState->stuff)(aState, &u.ch, 1);
        if (rv < 0) {
          return rv;
        }
        if (flags & _LEFT) {
          while (width-- > 1) {
            rv = (*aState->stuff)(aState, &space, 1);
            if (rv < 0) {
              return rv;
            }
          }
        }
        break;

      case 'p':
        if (sizeof(void*) == sizeof(int32_t)) {
          type = NumArgState::UINT32;
        } else if (sizeof(void*) == sizeof(int64_t)) {
          type = NumArgState::UINT64;
        } else if (sizeof(void*) == sizeof(int)) {
          type = NumArgState::UINTN;
        } else {
          PR_ASSERT(0);
          break;
        }
        radix = 16;
        goto fetch_and_convert;

#if 0
      case 'C':
        /* XXX not supported I suppose */
        PR_ASSERT(0);
        break;
#endif

      case 'S':
        u.S = va_arg(aAp, const char16_t*);
        rv = cvt_S(aState, u.S, width, prec, flags);
        if (rv < 0) {
          return rv;
        }
        break;

      case 's':
        u.s = va_arg(aAp, const char*);
        rv = cvt_s(aState, u.s, width, prec, flags);
        if (rv < 0) {
          return rv;
        }
        break;

      case 'n':
        u.ip = va_arg(aAp, int*);
        if (u.ip) {
          *u.ip = aState->cur - aState->base;
        }
        break;

      default:
        /* Not a % token after all... skip it */
#if 0
        PR_ASSERT(0);
#endif
        char16_t perct = '%';
        rv = (*aState->stuff)(aState, &perct, 1);
        if (rv < 0) {
          return rv;
        }
        rv = (*aState->stuff)(aState, aFmt - 1, 1);
        if (rv < 0) {
          return rv;
        }
    }
  }

  /* Stuff trailing NUL */
  char16_t null = '\0';

  rv = (*aState->stuff)(aState, &null, 1);

  if (nas && (nas != nasArray)) {
    PR_DELETE(nas);
  }

  return rv;
}

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

static int
StringStuff(SprintfState* aState, const char16_t* aStr, uint32_t aLen)
{
  if (*aStr == '\0') {
    return 0;
  }

  ptrdiff_t off = aState->cur - aState->base;

  nsAString* str = static_cast<nsAString*>(aState->stuffclosure);
  str->Append(aStr, aLen);

  aState->base = str->BeginWriting();
  aState->cur = aState->base + off;

  return 0;
}

/*
** Stuff routine that automatically grows the malloc'd output buffer
** before it overflows.
*/
static int
GrowStuff(SprintfState* aState, const char16_t* aStr, uint32_t aLen)
{
  ptrdiff_t off;
  char16_t* newbase;
  uint32_t newlen;

  off = aState->cur - aState->base;
  if (off + aLen >= aState->maxlen) {
    /* Grow the buffer */
    newlen = aState->maxlen + ((aLen > 32) ? aLen : 32);
    if (aState->base) {
      newbase = (char16_t*)moz_xrealloc(aState->base,
                                        newlen * sizeof(char16_t));
    } else {
      newbase = (char16_t*)moz_xmalloc(newlen * sizeof(char16_t));
    }
    if (!newbase) {
      /* Ran out of memory */
      return -1;
    }
    aState->base = newbase;
    aState->maxlen = newlen;
    aState->cur = aState->base + off;
  }

  /* Copy data */
  while (aLen) {
    --aLen;
    *aState->cur++ = *aStr++;
  }
  PR_ASSERT((uint32_t)(aState->cur - aState->base) <= aState->maxlen);
  return 0;
}

/*
** sprintf into a malloc'd buffer
*/
char16_t*
nsTextFormatter::smprintf(const char16_t* aFmt, ...)
{
  va_list ap;
  char16_t* rv;

  va_start(ap, aFmt);
  rv = nsTextFormatter::vsmprintf(aFmt, ap);
  va_end(ap);
  return rv;
}

uint32_t
nsTextFormatter::ssprintf(nsAString& aOut, const char16_t* aFmt, ...)
{
  va_list ap;
  uint32_t rv;

  va_start(ap, aFmt);
  rv = nsTextFormatter::vssprintf(aOut, aFmt, ap);
  va_end(ap);
  return rv;
}

uint32_t
nsTextFormatter::vssprintf(nsAString& aOut, const char16_t* aFmt, va_list aAp)
{
  SprintfState ss;
  ss.stuff = StringStuff;
  ss.base = 0;
  ss.cur = 0;
  ss.maxlen = 0;
  ss.stuffclosure = &aOut;

  aOut.Truncate();
  int n = dosprintf(&ss, aFmt, aAp);
  return n ? n - 1 : n;
}

char16_t*
nsTextFormatter::vsmprintf(const char16_t* aFmt, va_list aAp)
{
  SprintfState ss;
  int rv;

  ss.stuff = GrowStuff;
  ss.base = 0;
  ss.cur = 0;
  ss.maxlen = 0;
  rv = dosprintf(&ss, aFmt, aAp);
  if (rv < 0) {
    if (ss.base) {
      PR_DELETE(ss.base);
    }
    return 0;
  }
  return ss.base;
}

/*
** Stuff routine that discards overflow data
*/
static int
LimitStuff(SprintfState* aState, const char16_t* aStr, uint32_t aLen)
{
  uint32_t limit = aState->maxlen - (aState->cur - aState->base);

  if (aLen > limit) {
    aLen = limit;
  }
  while (aLen) {
    --aLen;
    *aState->cur++ = *aStr++;
  }
  return 0;
}

/*
** sprintf into a fixed size buffer. Make sure there is a NUL at the end
** when finished.
*/
uint32_t
nsTextFormatter::snprintf(char16_t* aOut, uint32_t aOutLen,
                          const char16_t* aFmt, ...)
{
  va_list ap;
  uint32_t rv;

  PR_ASSERT((int32_t)aOutLen > 0);
  if ((int32_t)aOutLen <= 0) {
    return 0;
  }

  va_start(ap, aFmt);
  rv = nsTextFormatter::vsnprintf(aOut, aOutLen, aFmt, ap);
  va_end(ap);
  return rv;
}

uint32_t
nsTextFormatter::vsnprintf(char16_t* aOut, uint32_t aOutLen,
                           const char16_t* aFmt, va_list aAp)
{
  SprintfState ss;
  uint32_t n;

  PR_ASSERT((int32_t)aOutLen > 0);
  if ((int32_t)aOutLen <= 0) {
    return 0;
  }

  ss.stuff = LimitStuff;
  ss.base = aOut;
  ss.cur = aOut;
  ss.maxlen = aOutLen;
  (void) dosprintf(&ss, aFmt, aAp);

  /* If we added chars, and we didn't append a null, do it now. */
  if ((ss.cur != ss.base) && (*(ss.cur - 1) != '\0')) {
    *(--ss.cur) = '\0';
  }

  n = ss.cur - ss.base;
  return n ? n - 1 : n;
}

/*
 * Free memory allocated, for the caller, by smprintf
 */
void
nsTextFormatter::smprintf_free(char16_t* aMem)
{
  free(aMem);
}