/* 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 <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include "primpl.h"
#include "prprf.h"
#include "prlong.h"
#include "prlog.h"
#include "prmem.h"

#if defined(_MSC_VER) && _MSC_VER < 1900
#  define snprintf _snprintf
#endif

/*
** WARNING: This code may *NOT* call PR_LOG (because PR_LOG calls it)
*/

/*
** XXX This needs to be internationalized!
*/

typedef struct SprintfStateStr SprintfState;

struct SprintfStateStr {
  int (*stuff)(SprintfState* ss, const char* sp, PRUint32 len);

  char* base;
  char* cur;
  PRUint32 maxlen; /* Must not exceed PR_INT32_MAX. */

  int (*func)(void* arg, const char* sp, PRUint32 len);
  void* arg;
};

/*
** Numbered Argument
*/
struct NumArg {
  int type; /* type of the numbered argument    */
  union {   /* the numbered argument            */
    int i;
    unsigned int ui;
    PRInt32 i32;
    PRUint32 ui32;
    PRInt64 ll;
    PRUint64 ull;
    double d;
    const char* s;
    int* ip;
#ifdef WIN32
    const WCHAR* ws;
#endif
  } u;
};

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

/*
** For numeric types, the signed versions must have even values,
** and their corresponding unsigned versions must have the subsequent
** odd value.
*/
#define TYPE_INT16 0
#define TYPE_UINT16 1
#define TYPE_INTN 2
#define TYPE_UINTN 3
#define TYPE_INT32 4
#define TYPE_UINT32 5
#define TYPE_INT64 6
#define TYPE_UINT64 7
#define TYPE_STRING 8
#define TYPE_DOUBLE 9
#define TYPE_INTSTR 10
#ifdef WIN32
#  define TYPE_WSTRING 11
#endif
#define TYPE_UNKNOWN 20

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

/*
** Fill into the buffer using the data in src
*/
static int fill2(SprintfState* ss, const char* src, int srclen, int width,
                 int flags) {
  char space = ' ';
  int rv;

  width -= srclen;
  if ((width > 0) && ((flags & FLAG_LEFT) == 0)) { /* Right adjusting */
    if (flags & FLAG_ZEROS) {
      space = '0';
    }
    while (--width >= 0) {
      rv = (*ss->stuff)(ss, &space, 1);
      if (rv < 0) {
        return rv;
      }
    }
  }

  /* Copy out the source data */
  rv = (*ss->stuff)(ss, src, srclen);
  if (rv < 0) {
    return rv;
  }

  if ((width > 0) && ((flags & FLAG_LEFT) != 0)) { /* Left adjusting */
    while (--width >= 0) {
      rv = (*ss->stuff)(ss, &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* ss, 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;
  int rv;
  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) {
    if (prec > srclen) {
      precwidth = prec - srclen; /* Need zero filling */
      cvtwidth += precwidth;
    }
  }

  if ((flags & FLAG_ZEROS) && (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) {
    rv = (*ss->stuff)(ss, " ", 1);
    if (rv < 0) {
      return rv;
    }
  }
  if (signwidth) {
    rv = (*ss->stuff)(ss, &sign, 1);
    if (rv < 0) {
      return rv;
    }
  }
  while (--precwidth >= 0) {
    rv = (*ss->stuff)(ss, "0", 1);
    if (rv < 0) {
      return rv;
    }
  }
  while (--zerowidth >= 0) {
    rv = (*ss->stuff)(ss, "0", 1);
    if (rv < 0) {
      return rv;
    }
  }
  rv = (*ss->stuff)(ss, src, srclen);
  if (rv < 0) {
    return rv;
  }
  while (--rightspaces >= 0) {
    rv = (*ss->stuff)(ss, " ", 1);
    if (rv < 0) {
      return rv;
    }
  }
  return 0;
}

/*
** Convert a long into its printable form
*/
static int cvt_l(SprintfState* ss, 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 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 + 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(ss, cvt, digits, width, prec, type, flags);
}

/*
** Convert a 64-bit integer into its printable form
*/
static int cvt_ll(SprintfState* ss, PRInt64 num, int width, int prec, int radix,
                  int type, int flags, const char* hexp) {
  char cvtbuf[100];
  char* cvt;
  int digits;
  PRInt64 rad;

  /* according to the man page this needs to happen */
  if ((prec == 0) && (LL_IS_ZERO(num))) {
    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.
  */
  LL_I2L(rad, radix);
  cvt = cvtbuf + sizeof(cvtbuf);
  digits = 0;
  while (!LL_IS_ZERO(num)) {
    PRInt32 digit;
    PRInt64 quot, rem;
    LL_UDIVMOD(&quot, &rem, num, rad);
    LL_L2I(digit, 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(ss, cvt, digits, width, prec, type, flags);
}

/*
** Convert a double precision floating point number into its printable
** form.
**
** XXX stop using snprintf to convert floating point
*/
static int cvt_f(SprintfState* ss, double d, const char* fmt0,
                 const char* fmt1) {
  char fin[20];
  char fout[300];
  int amount = fmt1 - fmt0;

  if (amount <= 0 || amount >= sizeof(fin)) {
    /* Totally bogus % command to snprintf. Just ignore it */
    return 0;
  }
  memcpy(fin, fmt0, amount);
  fin[amount] = 0;

  /* Convert floating point using the native snprintf code */
#ifdef DEBUG
  {
    const char* p = fin;
    while (*p) {
      PR_ASSERT(*p != 'L');
      p++;
    }
  }
#endif
  memset(fout, 0, sizeof(fout));
  snprintf(fout, sizeof(fout), fin, d);
  /* Explicitly null-terminate fout because on Windows snprintf doesn't
   * append a null-terminator if the buffer is too small. */
  fout[sizeof(fout) - 1] = '\0';

  return (*ss->stuff)(ss, fout, strlen(fout));
}

/*
** 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.
*/
static int cvt_s(SprintfState* ss, const char* str, int width, int prec,
                 int flags) {
  int slen;

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

  /* Limit string length by precision value */
  if (!str) {
    str = "(null)";
  }
  if (prec > 0) {
    /* this is:  slen = strnlen(str, prec); */
    register const char* s;

    for (s = str; prec && *s; s++, prec--);
    slen = s - str;
  } else {
    slen = strlen(str);
  }

  /* and away we go */
  return fill2(ss, str, slen, width, flags);
}

/*
** BuildArgArray stands for Numbered Argument list Sprintf
** for example,
**  fmt = "%4$i, %2$d, %3s, %1d";
** the number must start from 1, and no gap among them
*/

static struct NumArg* BuildArgArray(const char* fmt, va_list ap, int* rv,
                                    struct NumArg* nasArray) {
  int number = 0, cn = 0, i;
  const char* p;
  char c;
  struct NumArg* nas;

  /*
  **  first pass:
  **  determine how many legal % I have got, then allocate space
  */

  p = fmt;
  *rv = 0;
  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) {
            *rv = -1;
            return NULL;
          }
          number++;
        } else { /* non-numbered argument case */
          if (number > 0) {
            *rv = -1;
            return NULL;
          }
          i = 1;
        }
        break;
      }

      c = *p++;
    }
  }

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

  if (number > NAS_DEFAULT_NUM) {
    nas = (struct NumArg*)PR_MALLOC(number * sizeof(struct NumArg));
    if (!nas) {
      *rv = -1;
      return NULL;
    }
  } else {
    nas = nasArray;
  }

  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) {
      *rv = -1;
      break;
    }

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

    c = *p++;

    /* width */
    if (c == '*') {
      /* not supported feature, for the argument is not numbered */
      *rv = -1;
      break;
    }

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

    /* precision */
    if (c == '.') {
      c = *p++;
      if (c == '*') {
        /* not supported feature, for the argument is not numbered */
        *rv = -1;
        break;
      }

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

    /* size */
    nas[cn].type = TYPE_INTN;
    if (c == 'h') {
      nas[cn].type = TYPE_INT16;
      c = *p++;
    } else if (c == 'L') {
      /* XXX not quite sure here */
      nas[cn].type = TYPE_INT64;
      c = *p++;
    } else if (c == 'l') {
      nas[cn].type = TYPE_INT32;
      c = *p++;
      if (c == 'l') {
        nas[cn].type = TYPE_INT64;
        c = *p++;
      }
    } else if (c == 'z') {
      if (sizeof(size_t) == sizeof(PRInt32)) {
        nas[cn].type = TYPE_INT32;
      } else if (sizeof(size_t) == sizeof(PRInt64)) {
        nas[cn].type = TYPE_INT64;
      } else {
        nas[cn].type = TYPE_UNKNOWN;
      }
      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 = TYPE_DOUBLE;
        break;

      case 'p':
        /* XXX should use cpp */
        if (sizeof(void*) == sizeof(PRInt32)) {
          nas[cn].type = TYPE_UINT32;
        } else if (sizeof(void*) == sizeof(PRInt64)) {
          nas[cn].type = TYPE_UINT64;
        } else if (sizeof(void*) == sizeof(PRIntn)) {
          nas[cn].type = TYPE_UINTN;
        } else {
          nas[cn].type = TYPE_UNKNOWN;
        }
        break;

      case 'S':
#ifdef WIN32
        nas[cn].type = TYPE_WSTRING;
        break;
#endif
      case 'C':
      case 'E':
      case 'G':
        /* XXX not supported I suppose */
        PR_ASSERT(0);
        nas[cn].type = TYPE_UNKNOWN;
        break;

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

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

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

    /* get a legal para. */
    if (nas[cn].type == TYPE_UNKNOWN) {
      *rv = -1;
      break;
    }
  }

  /*
  ** third pass
  ** fill the nas[cn].ap
  */

  if (*rv < 0) {
    if (nas != nasArray) {
      PR_DELETE(nas);
    }
    return NULL;
  }

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

    switch (nas[cn].type) {
      case TYPE_INT16:
      case TYPE_UINT16:
      case TYPE_INTN:
        nas[cn].u.i = va_arg(ap, int);
        break;

      case TYPE_UINTN:
        nas[cn].u.ui = va_arg(ap, unsigned int);
        break;

      case TYPE_INT32:
        nas[cn].u.i32 = va_arg(ap, PRInt32);
        break;

      case TYPE_UINT32:
        nas[cn].u.ui32 = va_arg(ap, PRUint32);
        break;

      case TYPE_INT64:
        nas[cn].u.ll = va_arg(ap, PRInt64);
        break;

      case TYPE_UINT64:
        nas[cn].u.ull = va_arg(ap, PRUint64);
        break;

      case TYPE_STRING:
        nas[cn].u.s = va_arg(ap, char*);
        break;

#ifdef WIN32
      case TYPE_WSTRING:
        nas[cn].u.ws = va_arg(ap, WCHAR*);
        break;
#endif

      case TYPE_INTSTR:
        nas[cn].u.ip = va_arg(ap, int*);
        break;

      case TYPE_DOUBLE:
        nas[cn].u.d = va_arg(ap, double);
        break;

      default:
        if (nas != nasArray) {
          PR_DELETE(nas);
        }
        *rv = -1;
        return NULL;
    }

    cn++;
  }

  return nas;
}

/*
** The workhorse sprintf code.
*/
static int dosprintf(SprintfState* ss, const char* fmt, va_list ap) {
  char c;
  int flags, width, prec, radix, type;
  union {
    char ch;
    int i;
    long l;
    PRInt64 ll;
    double d;
    const char* s;
    int* ip;
#ifdef WIN32
    const WCHAR* ws;
#endif
  } u;
  const char* fmt0;
  static char* hex = "0123456789abcdef";
  static char* HEX = "0123456789ABCDEF";
  char* hexp;
  int rv, i;
  struct NumArg* nas = NULL;
  struct NumArg* nap = NULL;
  struct NumArg nasArray[NAS_DEFAULT_NUM];
  char pattern[20];
  const char* dolPt = NULL; /* in "%4$.2f", dolPt will point to . */
#ifdef WIN32
  char* pBuf = NULL;
#endif

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

  nas = BuildArgArray(fmt, ap, &rv, nasArray);
  if (rv < 0) {
    /* the fmt contains error Numbered Argument format, jliu@netscape.com */
    PR_ASSERT(0);
    return rv;
  }

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

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

    if (nas != NULL) {
      /* 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) {
        if (nas && (nas != nasArray)) {
          PR_DELETE(nas);
        }
        return -1;
      }

      nap = &nas[i - 1];
      dolPt = fmt;
      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);
    } 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_INT16;
      c = *fmt++;
    } else if (c == 'L') {
      /* XXX not quite sure here */
      type = TYPE_INT64;
      c = *fmt++;
    } else if (c == 'l') {
      type = TYPE_INT32;
      c = *fmt++;
      if (c == 'l') {
        type = TYPE_INT64;
        c = *fmt++;
      }
    } else if (c == 'z') {
      if (sizeof(size_t) == sizeof(PRInt32)) {
        type = TYPE_INT32;
      } else if (sizeof(size_t) == sizeof(PRInt64)) {
        type = TYPE_INT64;
      }
      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_INT16:
            u.l = nas ? nap->u.i : va_arg(ap, int);
            if (u.l < 0) {
              u.l = -u.l;
              flags |= FLAG_NEG;
            }
            goto do_long;
          case TYPE_UINT16:
            u.l = (nas ? nap->u.i : va_arg(ap, int)) & 0xffff;
            goto do_long;
          case TYPE_INTN:
            u.l = nas ? nap->u.i : va_arg(ap, int);
            if (u.l < 0) {
              u.l = -u.l;
              flags |= FLAG_NEG;
            }
            goto do_long;
          case TYPE_UINTN:
            u.l = (long)(nas ? nap->u.ui : va_arg(ap, unsigned int));
            goto do_long;

          case TYPE_INT32:
            u.l = nas ? nap->u.i32 : va_arg(ap, PRInt32);
            if (u.l < 0) {
              u.l = -u.l;
              flags |= FLAG_NEG;
            }
            goto do_long;
          case TYPE_UINT32:
            u.l = (long)(nas ? nap->u.ui32 : va_arg(ap, PRUint32));
          do_long:
            rv = cvt_l(ss, u.l, width, prec, radix, type, flags, hexp);
            if (rv < 0) {
              return rv;
            }
            break;

          case TYPE_INT64:
            u.ll = nas ? nap->u.ll : va_arg(ap, PRInt64);
            if (!LL_GE_ZERO(u.ll)) {
              LL_NEG(u.ll, u.ll);
              flags |= FLAG_NEG;
            }
            goto do_longlong;
          case TYPE_UINT64:
            u.ll = nas ? nap->u.ull : va_arg(ap, PRUint64);
          do_longlong:
            rv = cvt_ll(ss, u.ll, width, prec, radix, type, flags, hexp);
            if (rv < 0) {
              return rv;
            }
            break;
        }
        break;

      case 'e':
      case 'E':
      case 'f':
      case 'g':
        u.d = nas ? nap->u.d : va_arg(ap, double);
        if (nas != NULL) {
          i = fmt - dolPt;
          if (i < sizeof(pattern)) {
            pattern[0] = '%';
            memcpy(&pattern[1], dolPt, i);
            rv = cvt_f(ss, u.d, pattern, &pattern[i + 1]);
          }
        } else {
          rv = cvt_f(ss, u.d, fmt0, fmt);
        }

        if (rv < 0) {
          return rv;
        }
        break;

      case 'c':
        u.ch = nas ? nap->u.i : va_arg(ap, int);
        if ((flags & FLAG_LEFT) == 0) {
          while (width-- > 1) {
            rv = (*ss->stuff)(ss, " ", 1);
            if (rv < 0) {
              return rv;
            }
          }
        }
        rv = (*ss->stuff)(ss, &u.ch, 1);
        if (rv < 0) {
          return rv;
        }
        if (flags & FLAG_LEFT) {
          while (width-- > 1) {
            rv = (*ss->stuff)(ss, " ", 1);
            if (rv < 0) {
              return rv;
            }
          }
        }
        break;

      case 'p':
        if (sizeof(void*) == sizeof(PRInt32)) {
          type = TYPE_UINT32;
        } else if (sizeof(void*) == sizeof(PRInt64)) {
          type = TYPE_UINT64;
        } else if (sizeof(void*) == sizeof(int)) {
          type = TYPE_UINTN;
        } else {
          PR_ASSERT(0);
          break;
        }
        radix = 16;
        goto fetch_and_convert;

#ifndef WIN32
      case 'S':
        /* XXX not supported I suppose */
        PR_ASSERT(0);
        break;
#endif

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

#ifdef WIN32
      case 'S':
        u.ws = nas ? nap->u.ws : va_arg(ap, const WCHAR*);

        /* Get the required size in rv */
        rv = WideCharToMultiByte(CP_ACP, 0, u.ws, -1, NULL, 0, NULL, NULL);
        if (rv == 0) {
          rv = 1;
        }
        pBuf = PR_MALLOC(rv);
        WideCharToMultiByte(CP_ACP, 0, u.ws, -1, pBuf, (int)rv, NULL, NULL);
        pBuf[rv - 1] = '\0';

        rv = cvt_s(ss, pBuf, width, prec, flags);

        /* We don't need the allocated buffer anymore */
        PR_Free(pBuf);
        if (rv < 0) {
          return rv;
        }
        break;

#endif

      case 's':
        u.s = nas ? nap->u.s : va_arg(ap, const char*);
        rv = cvt_s(ss, u.s, width, prec, flags);
        if (rv < 0) {
          return rv;
        }
        break;

      case 'n':
        u.ip = nas ? nap->u.ip : va_arg(ap, int*);
        if (u.ip) {
          *u.ip = ss->cur - ss->base;
        }
        break;

      default:
        /* Not a % token after all... skip it */
#if 0
                PR_ASSERT(0);
#endif
        rv = (*ss->stuff)(ss, "%", 1);
        if (rv < 0) {
          return rv;
        }
        rv = (*ss->stuff)(ss, fmt - 1, 1);
        if (rv < 0) {
          return rv;
        }
    }
  }

  /* Stuff trailing NUL */
  rv = (*ss->stuff)(ss, "\0", 1);

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

  return rv;
}

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

static int FuncStuff(SprintfState* ss, const char* sp, PRUint32 len) {
  int rv;

  /*
  ** We will add len to ss->maxlen at the end of the function. First check
  ** if ss->maxlen + len would overflow or be greater than PR_INT32_MAX.
  */
  if (PR_UINT32_MAX - ss->maxlen < len || ss->maxlen + len > PR_INT32_MAX) {
    return -1;
  }
  rv = (*ss->func)(ss->arg, sp, len);
  if (rv < 0) {
    return rv;
  }
  ss->maxlen += len;
  return 0;
}

PR_IMPLEMENT(PRUint32)
PR_sxprintf(PRStuffFunc func, void* arg, const char* fmt, ...) {
  va_list ap;
  PRUint32 rv;

  va_start(ap, fmt);
  rv = PR_vsxprintf(func, arg, fmt, ap);
  va_end(ap);
  return rv;
}

PR_IMPLEMENT(PRUint32)
PR_vsxprintf(PRStuffFunc func, void* arg, const char* fmt, va_list ap) {
  SprintfState ss;
  int rv;

  ss.stuff = FuncStuff;
  ss.func = func;
  ss.arg = arg;
  ss.maxlen = 0;
  rv = dosprintf(&ss, fmt, ap);
  return (rv < 0) ? (PRUint32)-1 : ss.maxlen;
}

/*
** Stuff routine that automatically grows the malloc'd output buffer
** before it overflows.
*/
static int GrowStuff(SprintfState* ss, const char* sp, PRUint32 len) {
  ptrdiff_t off;
  char* newbase;
  PRUint32 newlen;

  off = ss->cur - ss->base;
  if (PR_UINT32_MAX - len < off) {
    /* off + len would be too big. */
    return -1;
  }
  if (off + len >= ss->maxlen) {
    /* Grow the buffer */
    PRUint32 increment = (len > 32) ? len : 32;
    if (PR_UINT32_MAX - ss->maxlen < increment) {
      /* ss->maxlen + increment would overflow. */
      return -1;
    }
    newlen = ss->maxlen + increment;
    if (newlen > PR_INT32_MAX) {
      return -1;
    }
    if (ss->base) {
      newbase = (char*)PR_REALLOC(ss->base, newlen);
    } else {
      newbase = (char*)PR_MALLOC(newlen);
    }
    if (!newbase) {
      /* Ran out of memory */
      return -1;
    }
    ss->base = newbase;
    ss->maxlen = newlen;
    ss->cur = ss->base + off;
  }

  /* Copy data */
  while (len) {
    --len;
    *ss->cur++ = *sp++;
  }
  PR_ASSERT((PRUint32)(ss->cur - ss->base) <= ss->maxlen);
  return 0;
}

/*
** sprintf into a malloc'd buffer
*/
PR_IMPLEMENT(char*) PR_smprintf(const char* fmt, ...) {
  va_list ap;
  char* rv;

  va_start(ap, fmt);
  rv = PR_vsmprintf(fmt, ap);
  va_end(ap);
  return rv;
}

/*
** Free memory allocated, for the caller, by PR_smprintf
*/
PR_IMPLEMENT(void) PR_smprintf_free(char* mem) { PR_DELETE(mem); }

PR_IMPLEMENT(char*) PR_vsmprintf(const char* fmt, va_list ap) {
  SprintfState ss;
  int rv;

  ss.stuff = GrowStuff;
  ss.base = 0;
  ss.cur = 0;
  ss.maxlen = 0;
  rv = dosprintf(&ss, fmt, ap);
  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* ss, const char* sp, PRUint32 len) {
  PRUint32 limit = ss->maxlen - (ss->cur - ss->base);

  if (len > limit) {
    len = limit;
  }
  while (len) {
    --len;
    *ss->cur++ = *sp++;
  }
  return 0;
}

/*
** sprintf into a fixed size buffer. Make sure there is a NUL at the end
** when finished.
*/
PR_IMPLEMENT(PRUint32)
PR_snprintf(char* out, PRUint32 outlen, const char* fmt, ...) {
  va_list ap;
  PRUint32 rv;

  va_start(ap, fmt);
  rv = PR_vsnprintf(out, outlen, fmt, ap);
  va_end(ap);
  return rv;
}

PR_IMPLEMENT(PRUint32)
PR_vsnprintf(char* out, PRUint32 outlen, const char* fmt, va_list ap) {
  SprintfState ss;
  PRUint32 n;

  PR_ASSERT(outlen != 0 && outlen <= PR_INT32_MAX);
  if (outlen == 0 || outlen > PR_INT32_MAX) {
    return 0;
  }

  ss.stuff = LimitStuff;
  ss.base = out;
  ss.cur = out;
  ss.maxlen = outlen;
  (void)dosprintf(&ss, fmt, ap);

  /* 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 - 1) = '\0';
  }

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

PR_IMPLEMENT(char*) PR_sprintf_append(char* last, const char* fmt, ...) {
  va_list ap;
  char* rv;

  va_start(ap, fmt);
  rv = PR_vsprintf_append(last, fmt, ap);
  va_end(ap);
  return rv;
}

PR_IMPLEMENT(char*)
PR_vsprintf_append(char* last, const char* fmt, va_list ap) {
  SprintfState ss;
  int rv;

  ss.stuff = GrowStuff;
  if (last) {
    size_t lastlen = strlen(last);
    if (lastlen > PR_INT32_MAX) {
      return 0;
    }
    ss.base = last;
    ss.cur = last + lastlen;
    ss.maxlen = lastlen;
  } else {
    ss.base = 0;
    ss.cur = 0;
    ss.maxlen = 0;
  }
  rv = dosprintf(&ss, fmt, ap);
  if (rv < 0) {
    if (ss.base) {
      PR_DELETE(ss.base);
    }
    return 0;
  }
  return ss.base;
}