[ tor-browser ].git.dasho

Printf.cpp (27711B)
      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
      2 * vim: set ts=8 sts=2 et sw=2 tw=80:
      3 * This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 /*
      8 * Portable safe sprintf code.
      9 *
     10 * Author: Kipp E.B. Hickman
     11 */
     12 
     13 #include "double-conversion/double-to-string.h"
     14 #include "mozilla/AllocPolicy.h"
     15 #include "mozilla/Printf.h"
     16 #include "mozilla/UniquePtrExtensions.h"
     17 #include "mozilla/Vector.h"
     18 
     19 #include <stdarg.h>
     20 #include <stdio.h>
     21 #include <stdlib.h>
     22 #include <string.h>
     23 
     24 #if defined(XP_WIN)
     25 #  include <windows.h>
     26 #endif
     27 
     28 using double_conversion::DoubleToStringConverter;
     29 using DTSC = DoubleToStringConverter;
     30 
     31 /*
     32 * Numbered Argument State
     33 */
     34 struct NumArgState {
     35  int type;    // type of the current ap
     36  va_list ap;  // point to the corresponding position on ap
     37 };
     38 
     39 using NumArgStateVector =
     40    mozilla::Vector<NumArgState, 20, mozilla::MallocAllocPolicy>;
     41 
     42 // For values up to and including TYPE_DOUBLE, the lowest bit indicates
     43 // whether the type is signed (0) or unsigned (1).
     44 #define TYPE_SHORT 0
     45 #define TYPE_USHORT 1
     46 #define TYPE_INTN 2
     47 #define TYPE_UINTN 3
     48 #define TYPE_LONG 4
     49 #define TYPE_ULONG 5
     50 #define TYPE_LONGLONG 6
     51 #define TYPE_ULONGLONG 7
     52 #define TYPE_DOUBLE 8
     53 #define TYPE_STRING 9
     54 #define TYPE_INTSTR 10
     55 #define TYPE_POINTER 11
     56 #if defined(XP_WIN)
     57 #  define TYPE_WSTRING 12
     58 #endif
     59 #define TYPE_SCHAR 14
     60 #define TYPE_UCHAR 15
     61 #define TYPE_UNKNOWN 20
     62 
     63 #define FLAG_LEFT 0x1
     64 #define FLAG_SIGNED 0x2
     65 #define FLAG_SPACED 0x4
     66 #define FLAG_ZEROS 0x8
     67 #define FLAG_NEG 0x10
     68 
     69 static const char hex[] = "0123456789abcdef";
     70 static const char HEX[] = "0123456789ABCDEF";
     71 
     72 // Fill into the buffer using the data in src
     73 bool mozilla::PrintfTarget::fill2(const char* src, int srclen, int width,
     74                                  int flags) {
     75  char space = ' ';
     76 
     77  width -= srclen;
     78  if (width > 0 && (flags & FLAG_LEFT) == 0) {  // Right adjusting
     79    if (flags & FLAG_ZEROS) {
     80      space = '0';
     81    }
     82    while (--width >= 0) {
     83      if (!emit(&space, 1)) {
     84        return false;
     85      }
     86    }
     87  }
     88 
     89  // Copy out the source data
     90  if (!emit(src, srclen)) {
     91    return false;
     92  }
     93 
     94  if (width > 0 && (flags & FLAG_LEFT) != 0) {  // Left adjusting
     95    while (--width >= 0) {
     96      if (!emit(&space, 1)) {
     97        return false;
     98      }
     99    }
    100  }
    101  return true;
    102 }
    103 
    104 /*
    105 * Fill a number. The order is: optional-sign zero-filling conversion-digits
    106 */
    107 bool mozilla::PrintfTarget::fill_n(const char* src, int srclen, int width,
    108                                   int prec, int type, int flags) {
    109  int zerowidth = 0;
    110  int precwidth = 0;
    111  int leftspaces = 0;
    112  int rightspaces = 0;
    113  int cvtwidth;
    114  char sign = 0;
    115 
    116  if ((type & 1) == 0) {
    117    if (flags & FLAG_NEG) {
    118      sign = '-';
    119    } else if (flags & FLAG_SIGNED) {
    120      sign = '+';
    121    } else if (flags & FLAG_SPACED) {
    122      sign = ' ';
    123    }
    124  }
    125  cvtwidth = (sign ? 1 : 0) + srclen;
    126 
    127  if (prec > 0 && (type != TYPE_DOUBLE)) {
    128    if (prec > srclen) {
    129      precwidth = prec - srclen;  // Need zero filling
    130      cvtwidth += precwidth;
    131    }
    132  }
    133 
    134  if ((flags & FLAG_ZEROS) && ((type == TYPE_DOUBLE) || (prec < 0))) {
    135    if (width > cvtwidth) {
    136      zerowidth = width - cvtwidth;  // Zero filling
    137      cvtwidth += zerowidth;
    138    }
    139  }
    140 
    141  if (flags & FLAG_LEFT) {
    142    if (width > cvtwidth) {
    143      // Space filling on the right (i.e. left adjusting)
    144      rightspaces = width - cvtwidth;
    145    }
    146  } else {
    147    if (width > cvtwidth) {
    148      // Space filling on the left (i.e. right adjusting)
    149      leftspaces = width - cvtwidth;
    150    }
    151  }
    152  while (--leftspaces >= 0) {
    153    if (!emit(" ", 1)) {
    154      return false;
    155    }
    156  }
    157  if (sign) {
    158    if (!emit(&sign, 1)) {
    159      return false;
    160    }
    161  }
    162  while (--precwidth >= 0) {
    163    if (!emit("0", 1)) {
    164      return false;
    165    }
    166  }
    167  while (--zerowidth >= 0) {
    168    if (!emit("0", 1)) {
    169      return false;
    170    }
    171  }
    172  if (!emit(src, uint32_t(srclen))) {
    173    return false;
    174  }
    175  while (--rightspaces >= 0) {
    176    if (!emit(" ", 1)) {
    177      return false;
    178    }
    179  }
    180  return true;
    181 }
    182 
    183 // All that the cvt_* functions care about as far as the TYPE_* constants is
    184 // that the low bit is set to indicate unsigned, or unset to indicate signed.
    185 // So we don't try to hard to ensure that the passed TYPE_* constant lines
    186 // up with the actual size of the number being printed here.  The main printf
    187 // code, below, does have to care so that the correct bits are extracted from
    188 // the varargs list.
    189 bool mozilla::PrintfTarget::appendIntDec(int32_t num) {
    190  int flags = 0;
    191  long n = num;
    192  if (n < 0) {
    193    n = -n;
    194    flags |= FLAG_NEG;
    195  }
    196  return cvt_l(n, -1, -1, 10, TYPE_INTN, flags, hex);
    197 }
    198 
    199 bool mozilla::PrintfTarget::appendIntDec(uint32_t num) {
    200  return cvt_l(num, -1, -1, 10, TYPE_UINTN, 0, hex);
    201 }
    202 
    203 bool mozilla::PrintfTarget::appendIntOct(uint32_t num) {
    204  return cvt_l(num, -1, -1, 8, TYPE_UINTN, 0, hex);
    205 }
    206 
    207 bool mozilla::PrintfTarget::appendIntHex(uint32_t num) {
    208  return cvt_l(num, -1, -1, 16, TYPE_UINTN, 0, hex);
    209 }
    210 
    211 bool mozilla::PrintfTarget::appendIntDec(int64_t num) {
    212  int flags = 0;
    213  if (num < 0) {
    214    num = -num;
    215    flags |= FLAG_NEG;
    216  }
    217  return cvt_ll(num, -1, -1, 10, TYPE_INTN, flags, hex);
    218 }
    219 
    220 bool mozilla::PrintfTarget::appendIntDec(uint64_t num) {
    221  return cvt_ll(num, -1, -1, 10, TYPE_UINTN, 0, hex);
    222 }
    223 
    224 bool mozilla::PrintfTarget::appendIntOct(uint64_t num) {
    225  return cvt_ll(num, -1, -1, 8, TYPE_UINTN, 0, hex);
    226 }
    227 
    228 bool mozilla::PrintfTarget::appendIntHex(uint64_t num) {
    229  return cvt_ll(num, -1, -1, 16, TYPE_UINTN, 0, hex);
    230 }
    231 
    232 /* Convert a long into its printable form. */
    233 bool mozilla::PrintfTarget::cvt_l(long num, int width, int prec, int radix,
    234                                  int type, int flags, const char* hexp) {
    235  char cvtbuf[100];
    236  char* cvt;
    237  int digits;
    238 
    239  // according to the man page this needs to happen
    240  if ((prec == 0) && (num == 0)) {
    241    return fill_n("", 0, width, prec, type, flags);
    242  }
    243 
    244  // Converting decimal is a little tricky. In the unsigned case we
    245  // need to stop when we hit 10 digits. In the signed case, we can
    246  // stop when the number is zero.
    247  cvt = cvtbuf + sizeof(cvtbuf);
    248  digits = 0;
    249  while (num) {
    250    int digit = (((unsigned long)num) % radix) & 0xF;
    251    *--cvt = hexp[digit];
    252    digits++;
    253    num = (long)(((unsigned long)num) / radix);
    254  }
    255  if (digits == 0) {
    256    *--cvt = '0';
    257    digits++;
    258  }
    259 
    260  // Now that we have the number converted without its sign, deal with
    261  // the sign and zero padding.
    262  return fill_n(cvt, digits, width, prec, type, flags);
    263 }
    264 
    265 /* Convert a 64-bit integer into its printable form. */
    266 bool mozilla::PrintfTarget::cvt_ll(int64_t num, int width, int prec, int radix,
    267                                   int type, int flags, const char* hexp) {
    268  // According to the man page, this needs to happen.
    269  if (prec == 0 && num == 0) {
    270    return fill_n("", 0, width, prec, type, flags);
    271  }
    272 
    273  // Converting decimal is a little tricky. In the unsigned case we
    274  // need to stop when we hit 10 digits. In the signed case, we can
    275  // stop when the number is zero.
    276  int64_t rad = int64_t(radix);
    277  char cvtbuf[100];
    278  char* cvt = cvtbuf + sizeof(cvtbuf);
    279  int digits = 0;
    280  while (num != 0) {
    281    int64_t quot = uint64_t(num) / rad;
    282    int64_t rem = uint64_t(num) % rad;
    283    int32_t digit = int32_t(rem);
    284    *--cvt = hexp[digit & 0xf];
    285    digits++;
    286    num = quot;
    287  }
    288  if (digits == 0) {
    289    *--cvt = '0';
    290    digits++;
    291  }
    292 
    293  // Now that we have the number converted without its sign, deal with
    294  // the sign and zero padding.
    295  return fill_n(cvt, digits, width, prec, type, flags);
    296 }
    297 
    298 template <size_t N>
    299 constexpr static size_t lengthof(const char (&)[N]) {
    300  return N - 1;
    301 }
    302 
    303 // Longest possible output from ToFixed for positive numbers:
    304 // [0-9]{kMaxFixedDigitsBeforePoint}\.[0-9]{kMaxFixedDigitsAfterPoint}?
    305 constexpr int FIXED_MAX_CHARS =
    306    DTSC::kMaxFixedDigitsBeforePoint + 1 + DTSC::kMaxFixedDigitsAfterPoint;
    307 
    308 // Longest possible output from ToExponential:
    309 // [1-9]\.[0-9]{kMaxExponentialDigits}e[+-][0-9]{1,3}
    310 // (std::numeric_limits<double>::max() has exponent 308).
    311 constexpr int EXPONENTIAL_MAX_CHARS =
    312    lengthof("1.") + DTSC::kMaxExponentialDigits + lengthof("e+999");
    313 
    314 // Longest possible output from ToPrecise:
    315 // [0-9\.]{kMaxPrecisionDigits+1} or
    316 // [1-9]\.[0-9]{kMaxPrecisionDigits-1}e[+-][0-9]{1,3}
    317 constexpr int PRECISE_MAX_CHARS =
    318    lengthof("1.") + DTSC::kMaxPrecisionDigits - 1 + lengthof("e+999");
    319 
    320 constexpr int DTSC_MAX_CHARS =
    321    std::max({FIXED_MAX_CHARS, EXPONENTIAL_MAX_CHARS, PRECISE_MAX_CHARS});
    322 
    323 /*
    324 * Convert a double precision floating point number into its printable
    325 * form.
    326 */
    327 bool mozilla::PrintfTarget::cvt_f(double d, char c, int width, int prec,
    328                                  int flags) {
    329  bool lower = islower(c);
    330  const char* inf = lower ? "inf" : "INF";
    331  const char* nan = lower ? "nan" : "NAN";
    332  char e = lower ? 'e' : 'E';
    333  DoubleToStringConverter converter(DTSC::UNIQUE_ZERO | DTSC::NO_TRAILING_ZERO |
    334                                        DTSC::EMIT_POSITIVE_EXPONENT_SIGN,
    335                                    inf, nan, e, 0, 0, 4, 0, 2);
    336  // Longest of the above cases, plus space for a terminal nul character.
    337  char buf[DTSC_MAX_CHARS + 1];
    338  double_conversion::StringBuilder builder(buf, sizeof(buf));
    339  bool success = false;
    340  if (std::signbit(d)) {
    341    d = std::abs(d);
    342    flags |= FLAG_NEG;
    343  }
    344  if (!std::isfinite(d)) {
    345    flags &= ~FLAG_ZEROS;
    346  }
    347  // "If the precision is missing, it shall be taken as 6."
    348  if (prec < 0) {
    349    prec = 6;
    350  }
    351  switch (c) {
    352    case 'e':
    353    case 'E':
    354      success = converter.ToExponential(d, prec, &builder);
    355      break;
    356    case 'f':
    357    case 'F':
    358      success = converter.ToFixed(d, prec, &builder);
    359      break;
    360    case 'g':
    361    case 'G':
    362      // "If an explicit precision is zero, it shall be taken as 1."
    363      success = converter.ToPrecision(d, prec ? prec : 1, &builder);
    364      break;
    365  }
    366  if (!success) {
    367    return false;
    368  }
    369  int len = builder.position();
    370  char* cvt = builder.Finalize();
    371  return fill_n(cvt, len, width, prec, TYPE_DOUBLE, flags);
    372 }
    373 
    374 /*
    375 * Convert a string into its printable form.  "width" is the output
    376 * width. "prec" is the maximum number of characters of "s" to output,
    377 * where -1 means until NUL.
    378 */
    379 bool mozilla::PrintfTarget::cvt_s(const char* s, int width, int prec,
    380                                  int flags) {
    381  if (prec == 0) {
    382    return true;
    383  }
    384  if (!s) {
    385    s = "(null)";
    386  }
    387 
    388  // Limit string length by precision value
    389  int slen = int(strlen(s));
    390  if (0 < prec && prec < slen) {
    391    slen = prec;
    392  }
    393 
    394  // and away we go
    395  return fill2(s, slen, width, flags);
    396 }
    397 
    398 /*
    399 * BuildArgArray stands for Numbered Argument list Sprintf
    400 * for example,
    401 *      fmp = "%4$i, %2$d, %3s, %1d";
    402 * the number must start from 1, and no gap among them
    403 */
    404 static bool BuildArgArray(const char* fmt, va_list ap, NumArgStateVector& nas) {
    405  size_t number = 0, cn = 0, i;
    406  const char* p;
    407  char c;
    408 
    409  // First pass:
    410  // Detemine how many legal % I have got, then allocate space.
    411 
    412  p = fmt;
    413  i = 0;
    414  while ((c = *p++) != 0) {
    415    if (c != '%') {
    416      continue;
    417    }
    418    if ((c = *p++) == '%') {  // skip %% case
    419      continue;
    420    }
    421 
    422    while (c != 0) {
    423      if (c > '9' || c < '0') {
    424        if (c == '$') {  // numbered argument case
    425          if (i > 0) {
    426            MOZ_CRASH("Bad format string");
    427          }
    428          number++;
    429        } else {  // non-numbered argument case
    430          if (number > 0) {
    431            MOZ_CRASH("Bad format string");
    432          }
    433          i = 1;
    434        }
    435        break;
    436      }
    437 
    438      c = *p++;
    439    }
    440  }
    441 
    442  if (number == 0) {
    443    return true;
    444  }
    445 
    446  // Only allow a limited number of arguments.
    447  MOZ_RELEASE_ASSERT(number <= 20);
    448 
    449  if (!nas.growByUninitialized(number)) {
    450    return false;
    451  }
    452 
    453  for (i = 0; i < number; i++) {
    454    nas[i].type = TYPE_UNKNOWN;
    455  }
    456 
    457  // Second pass:
    458  // Set nas[].type.
    459 
    460  p = fmt;
    461  while ((c = *p++) != 0) {
    462    if (c != '%') {
    463      continue;
    464    }
    465    c = *p++;
    466    if (c == '%') {
    467      continue;
    468    }
    469 
    470    cn = 0;
    471    while (c && c != '$') {  // should improve error check later
    472      cn = cn * 10 + c - '0';
    473      c = *p++;
    474    }
    475 
    476    if (!c || cn < 1 || cn > number) {
    477      MOZ_CRASH("Bad format string");
    478    }
    479 
    480    // nas[cn] starts from 0, and make sure nas[cn].type is not assigned.
    481    cn--;
    482    if (nas[cn].type != TYPE_UNKNOWN) {
    483      continue;
    484    }
    485 
    486    c = *p++;
    487 
    488    // flags
    489    while ((c == '-') || (c == '+') || (c == ' ') || (c == '0')) {
    490      c = *p++;
    491    }
    492 
    493    // width
    494    if (c == '*') {
    495      // not supported feature, for the argument is not numbered
    496      MOZ_CRASH("Bad format string");
    497    }
    498 
    499    while ((c >= '0') && (c <= '9')) {
    500      c = *p++;
    501    }
    502 
    503    // precision
    504    if (c == '.') {
    505      c = *p++;
    506      if (c == '*') {
    507        // not supported feature, for the argument is not numbered
    508        MOZ_CRASH("Bad format string");
    509      }
    510 
    511      while ((c >= '0') && (c <= '9')) {
    512        c = *p++;
    513      }
    514    }
    515 
    516    // size
    517    nas[cn].type = TYPE_INTN;
    518    if (c == 'h') {
    519      nas[cn].type = TYPE_SHORT;
    520      c = *p++;
    521      if (c == 'h') {
    522        nas[cn].type = TYPE_SCHAR;
    523        c = *p++;
    524      }
    525    } else if (c == 'L') {
    526      nas[cn].type = TYPE_LONGLONG;
    527      c = *p++;
    528    } else if (c == 'l') {
    529      nas[cn].type = TYPE_LONG;
    530      c = *p++;
    531      if (c == 'l') {
    532        nas[cn].type = TYPE_LONGLONG;
    533        c = *p++;
    534      }
    535    } else if (c == 'z' || c == 'I') {
    536      static_assert(sizeof(size_t) == sizeof(int) ||
    537                        sizeof(size_t) == sizeof(long) ||
    538                        sizeof(size_t) == sizeof(long long),
    539                    "size_t is not one of the expected sizes");
    540      nas[cn].type = sizeof(size_t) == sizeof(int)    ? TYPE_INTN
    541                     : sizeof(size_t) == sizeof(long) ? TYPE_LONG
    542                                                      : TYPE_LONGLONG;
    543      c = *p++;
    544    } else if (c == 't') {
    545      static_assert(sizeof(ptrdiff_t) == sizeof(int) ||
    546                        sizeof(ptrdiff_t) == sizeof(long) ||
    547                        sizeof(ptrdiff_t) == sizeof(long long),
    548                    "ptrdiff_t is not one of the expected sizes");
    549      nas[cn].type = sizeof(ptrdiff_t) == sizeof(int)    ? TYPE_INTN
    550                     : sizeof(ptrdiff_t) == sizeof(long) ? TYPE_LONG
    551                                                         : TYPE_LONGLONG;
    552      c = *p++;
    553    } else if (c == 'j') {
    554      static_assert(sizeof(intmax_t) == sizeof(int) ||
    555                        sizeof(intmax_t) == sizeof(long) ||
    556                        sizeof(intmax_t) == sizeof(long long),
    557                    "intmax_t is not one of the expected sizes");
    558      nas[cn].type = sizeof(intmax_t) == sizeof(int)    ? TYPE_INTN
    559                     : sizeof(intmax_t) == sizeof(long) ? TYPE_LONG
    560                                                        : TYPE_LONGLONG;
    561      c = *p++;
    562    }
    563 
    564    // format
    565    switch (c) {
    566      case 'd':
    567      case 'c':
    568      case 'i':
    569        break;
    570 
    571      case 'o':
    572      case 'u':
    573      case 'x':
    574      case 'X':
    575        // Mark as unsigned type.
    576        nas[cn].type |= 1;
    577        break;
    578 
    579      case 'e':
    580      case 'E':
    581      case 'f':
    582      case 'F':
    583      case 'g':
    584      case 'G':
    585        nas[cn].type = TYPE_DOUBLE;
    586        break;
    587 
    588      case 'p':
    589        nas[cn].type = TYPE_POINTER;
    590        break;
    591 
    592      case 'S':
    593 #if defined(XP_WIN)
    594        nas[cn].type = TYPE_WSTRING;
    595 #else
    596        MOZ_ASSERT(0);
    597        nas[cn].type = TYPE_UNKNOWN;
    598 #endif
    599        break;
    600 
    601      case 's':
    602 #if defined(XP_WIN)
    603        if (nas[cn].type == TYPE_LONG) {
    604          nas[cn].type = TYPE_WSTRING;
    605          break;
    606        }
    607 #endif
    608        // Other type sizes are not supported here.
    609        MOZ_ASSERT(nas[cn].type == TYPE_INTN);
    610        nas[cn].type = TYPE_STRING;
    611        break;
    612 
    613      case 'n':
    614        nas[cn].type = TYPE_INTSTR;
    615        break;
    616 
    617      default:
    618        MOZ_ASSERT(0);
    619        nas[cn].type = TYPE_UNKNOWN;
    620        break;
    621    }
    622 
    623    // get a legal para.
    624    if (nas[cn].type == TYPE_UNKNOWN) {
    625      MOZ_CRASH("Bad format string");
    626    }
    627  }
    628 
    629  // Third pass:
    630  // Fill nas[].ap.
    631 
    632  cn = 0;
    633  while (cn < number) {
    634    // A TYPE_UNKNOWN here means that the format asked for a
    635    // positional argument without specifying the meaning of some
    636    // earlier argument.
    637    MOZ_ASSERT(nas[cn].type != TYPE_UNKNOWN);
    638 
    639    va_copy(nas[cn].ap, ap);
    640 
    641    switch (nas[cn].type) {
    642      case TYPE_SCHAR:
    643      case TYPE_UCHAR:
    644      case TYPE_SHORT:
    645      case TYPE_USHORT:
    646      case TYPE_INTN:
    647      case TYPE_UINTN:
    648        (void)va_arg(ap, int);
    649        break;
    650      case TYPE_LONG:
    651        (void)va_arg(ap, long);
    652        break;
    653      case TYPE_ULONG:
    654        (void)va_arg(ap, unsigned long);
    655        break;
    656      case TYPE_LONGLONG:
    657        (void)va_arg(ap, long long);
    658        break;
    659      case TYPE_ULONGLONG:
    660        (void)va_arg(ap, unsigned long long);
    661        break;
    662      case TYPE_STRING:
    663        (void)va_arg(ap, char*);
    664        break;
    665      case TYPE_INTSTR:
    666        (void)va_arg(ap, int*);
    667        break;
    668      case TYPE_DOUBLE:
    669        (void)va_arg(ap, double);
    670        break;
    671      case TYPE_POINTER:
    672        (void)va_arg(ap, void*);
    673        break;
    674 #if defined(XP_WIN)
    675      case TYPE_WSTRING:
    676        (void)va_arg(ap, wchar_t*);
    677        break;
    678 #endif
    679 
    680      default:
    681        MOZ_CRASH();
    682    }
    683 
    684    cn++;
    685  }
    686 
    687  return true;
    688 }
    689 
    690 mozilla::PrintfTarget::PrintfTarget() : mEmitted(0) {}
    691 
    692 bool mozilla::PrintfTarget::vprint(const char* fmt, va_list ap) {
    693  char c;
    694  int flags, width, prec, radix, type;
    695  union {
    696    char ch;
    697    int i;
    698    long l;
    699    long long ll;
    700    double d;
    701    const char* s;
    702    int* ip;
    703    void* p;
    704 #if defined(XP_WIN)
    705    const wchar_t* ws;
    706 #endif
    707  } u{};
    708  const char* hexp;
    709  int i;
    710 
    711  // Build an argument array, IF the fmt is numbered argument
    712  // list style, to contain the Numbered Argument list pointers.
    713 
    714  NumArgStateVector nas;
    715  if (!BuildArgArray(fmt, ap, nas)) {
    716    // the fmt contains error Numbered Argument format, jliu@netscape.com
    717    MOZ_CRASH("Bad format string");
    718  }
    719 
    720  while ((c = *fmt++) != 0) {
    721    if (c != '%') {
    722      if (!emit(fmt - 1, 1)) {
    723        return false;
    724      }
    725 
    726      continue;
    727    }
    728 
    729    // Gobble up the % format string. Hopefully we have handled all
    730    // of the strange cases!
    731    flags = 0;
    732    c = *fmt++;
    733    if (c == '%') {
    734      // quoting a % with %%
    735      if (!emit(fmt - 1, 1)) {
    736        return false;
    737      }
    738 
    739      continue;
    740    }
    741 
    742    if (!nas.empty()) {
    743      // the fmt contains the Numbered Arguments feature
    744      i = 0;
    745      while (c && c != '$') {  // should improve error check later
    746        i = (i * 10) + (c - '0');
    747        c = *fmt++;
    748      }
    749 
    750      if (nas[i - 1].type == TYPE_UNKNOWN) {
    751        MOZ_CRASH("Bad format string");
    752      }
    753 
    754      ap = nas[i - 1].ap;
    755      c = *fmt++;
    756    }
    757 
    758    // Examine optional flags.  Note that we do not implement the
    759    // '#' flag of sprintf().  The ANSI C spec. of the '#' flag is
    760    // somewhat ambiguous and not ideal, which is perhaps why
    761    // the various sprintf() implementations are inconsistent
    762    // on this feature.
    763    while ((c == '-') || (c == '+') || (c == ' ') || (c == '0')) {
    764      if (c == '-') {
    765        flags |= FLAG_LEFT;
    766      }
    767      if (c == '+') {
    768        flags |= FLAG_SIGNED;
    769      }
    770      if (c == ' ') {
    771        flags |= FLAG_SPACED;
    772      }
    773      if (c == '0') {
    774        flags |= FLAG_ZEROS;
    775      }
    776      c = *fmt++;
    777    }
    778    if (flags & FLAG_SIGNED) {
    779      flags &= ~FLAG_SPACED;
    780    }
    781    if (flags & FLAG_LEFT) {
    782      flags &= ~FLAG_ZEROS;
    783    }
    784 
    785    // width
    786    if (c == '*') {
    787      c = *fmt++;
    788      width = va_arg(ap, int);
    789      if (width < 0) {
    790        width = -width;
    791        flags |= FLAG_LEFT;
    792        flags &= ~FLAG_ZEROS;
    793      }
    794    } else {
    795      width = 0;
    796      while ((c >= '0') && (c <= '9')) {
    797        width = (width * 10) + (c - '0');
    798        c = *fmt++;
    799      }
    800    }
    801 
    802    // precision
    803    prec = -1;
    804    if (c == '.') {
    805      c = *fmt++;
    806      if (c == '*') {
    807        c = *fmt++;
    808        prec = va_arg(ap, int);
    809      } else {
    810        prec = 0;
    811        while ((c >= '0') && (c <= '9')) {
    812          prec = (prec * 10) + (c - '0');
    813          c = *fmt++;
    814        }
    815      }
    816    }
    817 
    818    // size
    819    type = TYPE_INTN;
    820    if (c == 'h') {
    821      type = TYPE_SHORT;
    822      c = *fmt++;
    823      if (c == 'h') {
    824        type = TYPE_SCHAR;
    825        c = *fmt++;
    826      }
    827    } else if (c == 'L') {
    828      type = TYPE_LONGLONG;
    829      c = *fmt++;
    830    } else if (c == 'l') {
    831      type = TYPE_LONG;
    832      c = *fmt++;
    833      if (c == 'l') {
    834        type = TYPE_LONGLONG;
    835        c = *fmt++;
    836      }
    837    } else if (c == 'z' || c == 'I') {
    838      static_assert(sizeof(size_t) == sizeof(int) ||
    839                        sizeof(size_t) == sizeof(long) ||
    840                        sizeof(size_t) == sizeof(long long),
    841                    "size_t is not one of the expected sizes");
    842      type = sizeof(size_t) == sizeof(int)    ? TYPE_INTN
    843             : sizeof(size_t) == sizeof(long) ? TYPE_LONG
    844                                              : TYPE_LONGLONG;
    845      c = *fmt++;
    846    } else if (c == 't') {
    847      static_assert(sizeof(ptrdiff_t) == sizeof(int) ||
    848                        sizeof(ptrdiff_t) == sizeof(long) ||
    849                        sizeof(ptrdiff_t) == sizeof(long long),
    850                    "ptrdiff_t is not one of the expected sizes");
    851      type = sizeof(ptrdiff_t) == sizeof(int)    ? TYPE_INTN
    852             : sizeof(ptrdiff_t) == sizeof(long) ? TYPE_LONG
    853                                                 : TYPE_LONGLONG;
    854      c = *fmt++;
    855    } else if (c == 'j') {
    856      static_assert(sizeof(intmax_t) == sizeof(int) ||
    857                        sizeof(intmax_t) == sizeof(long) ||
    858                        sizeof(intmax_t) == sizeof(long long),
    859                    "intmax_t is not one of the expected sizes");
    860      type = sizeof(intmax_t) == sizeof(int)    ? TYPE_INTN
    861             : sizeof(intmax_t) == sizeof(long) ? TYPE_LONG
    862                                                : TYPE_LONGLONG;
    863      c = *fmt++;
    864    }
    865 
    866    // format
    867    hexp = hex;
    868    switch (c) {
    869      case 'd':
    870      case 'i':  // decimal/integer
    871        radix = 10;
    872        goto fetch_and_convert;
    873 
    874      case 'o':  // octal
    875        radix = 8;
    876        type |= 1;
    877        goto fetch_and_convert;
    878 
    879      case 'u':  // unsigned decimal
    880        radix = 10;
    881        type |= 1;
    882        goto fetch_and_convert;
    883 
    884      case 'x':  // unsigned hex
    885        radix = 16;
    886        type |= 1;
    887        goto fetch_and_convert;
    888 
    889      case 'X':  // unsigned HEX
    890        radix = 16;
    891        hexp = HEX;
    892        type |= 1;
    893        goto fetch_and_convert;
    894 
    895      fetch_and_convert:
    896        switch (type) {
    897          case TYPE_SCHAR:
    898            u.l = (signed char)va_arg(ap, int);
    899            if (u.l < 0) {
    900              u.l = -u.l;
    901              flags |= FLAG_NEG;
    902            }
    903            goto do_long;
    904          case TYPE_UCHAR:
    905            u.l = (unsigned char)va_arg(ap, unsigned int);
    906            goto do_long;
    907          case TYPE_SHORT:
    908            u.l = (short)va_arg(ap, int);
    909            if (u.l < 0) {
    910              u.l = -u.l;
    911              flags |= FLAG_NEG;
    912            }
    913            goto do_long;
    914          case TYPE_USHORT:
    915            u.l = (unsigned short)va_arg(ap, unsigned int);
    916            goto do_long;
    917          case TYPE_INTN:
    918            u.l = va_arg(ap, int);
    919            if (u.l < 0) {
    920              u.l = -u.l;
    921              flags |= FLAG_NEG;
    922            }
    923            goto do_long;
    924          case TYPE_UINTN:
    925            u.l = (long)va_arg(ap, unsigned int);
    926            goto do_long;
    927 
    928          case TYPE_LONG:
    929            u.l = va_arg(ap, long);
    930            if (u.l < 0) {
    931              u.l = -u.l;
    932              flags |= FLAG_NEG;
    933            }
    934            goto do_long;
    935          case TYPE_ULONG:
    936            u.l = (long)va_arg(ap, unsigned long);
    937          do_long:
    938            if (!cvt_l(u.l, width, prec, radix, type, flags, hexp)) {
    939              return false;
    940            }
    941 
    942            break;
    943 
    944          case TYPE_LONGLONG:
    945            u.ll = va_arg(ap, long long);
    946            if (u.ll < 0) {
    947              u.ll = -u.ll;
    948              flags |= FLAG_NEG;
    949            }
    950            goto do_longlong;
    951          case TYPE_POINTER:
    952            u.ll = (uintptr_t)va_arg(ap, void*);
    953            goto do_longlong;
    954          case TYPE_ULONGLONG:
    955            u.ll = va_arg(ap, unsigned long long);
    956          do_longlong:
    957            if (!cvt_ll(u.ll, width, prec, radix, type, flags, hexp)) {
    958              return false;
    959            }
    960 
    961            break;
    962        }
    963        break;
    964 
    965      case 'e':
    966      case 'E':
    967      case 'f':
    968      case 'F':
    969      case 'g':
    970      case 'G':
    971        u.d = va_arg(ap, double);
    972        if (!cvt_f(u.d, c, width, prec, flags)) {
    973          return false;
    974        }
    975 
    976        break;
    977 
    978      case 'c':
    979        if ((flags & FLAG_LEFT) == 0) {
    980          while (width-- > 1) {
    981            if (!emit(" ", 1)) {
    982              return false;
    983            }
    984          }
    985        }
    986        switch (type) {
    987          case TYPE_SHORT:
    988          case TYPE_INTN:
    989            u.ch = va_arg(ap, int);
    990            if (!emit(&u.ch, 1)) {
    991              return false;
    992            }
    993            break;
    994        }
    995        if (flags & FLAG_LEFT) {
    996          while (width-- > 1) {
    997            if (!emit(" ", 1)) {
    998              return false;
    999            }
   1000          }
   1001        }
   1002        break;
   1003 
   1004      case 'p':
   1005        type = TYPE_POINTER;
   1006        radix = 16;
   1007        goto fetch_and_convert;
   1008 
   1009      case 's':
   1010        if (type == TYPE_INTN) {
   1011          u.s = va_arg(ap, const char*);
   1012          if (!cvt_s(u.s, width, prec, flags)) {
   1013            return false;
   1014          }
   1015          break;
   1016        }
   1017        MOZ_ASSERT(type == TYPE_LONG);
   1018        [[fallthrough]];
   1019      case 'S':
   1020 #if defined(XP_WIN)
   1021      {
   1022        u.ws = va_arg(ap, const wchar_t*);
   1023 
   1024        int rv = WideCharToMultiByte(CP_ACP, 0, u.ws, -1, NULL, 0, NULL, NULL);
   1025        if (rv == 0 && GetLastError() == ERROR_NO_UNICODE_TRANSLATION) {
   1026          if (!cvt_s("<unicode errors in string>", width, prec, flags)) {
   1027            return false;
   1028          }
   1029        } else {
   1030          if (rv == 0) {
   1031            rv = 1;
   1032          }
   1033          UniqueFreePtr<char[]> buf((char*)malloc(rv));
   1034          WideCharToMultiByte(CP_ACP, 0, u.ws, -1, buf.get(), rv, NULL, NULL);
   1035          buf[rv - 1] = '\0';
   1036 
   1037          if (!cvt_s(buf.get(), width, prec, flags)) {
   1038            return false;
   1039          }
   1040        }
   1041      }
   1042 #else
   1043        // Not supported here.
   1044        MOZ_ASSERT(0);
   1045 #endif
   1046      break;
   1047 
   1048      case 'n':
   1049        u.ip = va_arg(ap, int*);
   1050        if (u.ip) {
   1051          *u.ip = mEmitted;
   1052        }
   1053        break;
   1054 
   1055      default:
   1056        // Not a % token after all... skip it
   1057        if (!emit("%", 1)) {
   1058          return false;
   1059        }
   1060        if (!emit(fmt - 1, 1)) {
   1061          return false;
   1062        }
   1063    }
   1064  }
   1065 
   1066  return true;
   1067 }
   1068 
   1069 /************************************************************************/
   1070 
   1071 bool mozilla::PrintfTarget::print(const char* format, ...) {
   1072  va_list ap;
   1073 
   1074  va_start(ap, format);
   1075  bool result = vprint(format, ap);
   1076  va_end(ap);
   1077  return result;
   1078 }
   1079 
   1080 #undef TYPE_SHORT
   1081 #undef TYPE_USHORT
   1082 #undef TYPE_INTN
   1083 #undef TYPE_UINTN
   1084 #undef TYPE_LONG
   1085 #undef TYPE_ULONG
   1086 #undef TYPE_LONGLONG
   1087 #undef TYPE_ULONGLONG
   1088 #undef TYPE_STRING
   1089 #undef TYPE_DOUBLE
   1090 #undef TYPE_INTSTR
   1091 #undef TYPE_POINTER
   1092 #undef TYPE_WSTRING
   1093 #undef TYPE_UNKNOWN
   1094 #undef TYPE_SCHAR
   1095 #undef TYPE_UCHAR
   1096 
   1097 #undef FLAG_LEFT
   1098 #undef FLAG_SIGNED
   1099 #undef FLAG_SPACED
   1100 #undef FLAG_ZEROS
   1101 #undef FLAG_NEG
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE