Quelle  FdPrintf.cpp

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

#include <cstdarg>

#ifdef _WIN32
#  include <windows.h>
#else
#  include <unistd.h>
#endif
#include <cmath>
#include <cstring>
#include <cstdint>
#include "mozilla/Assertions.h"
#include "FdPrintf.h"

/* Template class allowing a limited number of increments on a value */
template <typename T>
class CheckedIncrement {
 public:
  CheckedIncrement(T aValue, size_t aMaxIncrement)
      : mValue(aValue), mMaxIncrement(aMaxIncrement) {}

  T operator++(int) {
    if (!mMaxIncrement) {
      MOZ_CRASH("overflow detected");
    }
    mMaxIncrement--;
    return mValue++;
  }

  T& operator++() {
    (*this)++;
    return mValue;
  }

  void advance(T end) {
    // Only makes sense if T is a pointer type.
    size_t diff = end - mValue;
    if (diff > mMaxIncrement) {
      MOZ_CRASH("overflow detected");
    }
    mMaxIncrement -= diff;
    mValue = end;
  }

  void rewind(T pos) {
    size_t diff = mValue - pos;
    mMaxIncrement += diff;
    mValue = pos;
  }

  operator T() { return mValue; }
  T value() { return mValue; }

 private:
  T mValue;
  size_t mMaxIncrement;
};

template <typename T>
static unsigned NumDigits(T n) {
  if (n < 1) {
    // We want one digit, it will be 0.
    return 1;
  }

  double l = log10(static_cast<double>(n));
  double cl = ceil(l);
  return l == cl ? unsigned(cl) + 1 : unsigned(cl);
}

static void LeftPad(CheckedIncrement<char*>& b, size_t pad) {
  while (pad-- > 0) {
    *(b++) = ' ';
  }
}

// Write the digits into the buffer.
static void WriteDigits(CheckedIncrement<char*>& b, size_t i,
                        size_t num_digits) {
  size_t x = pow(10, double(num_digits - 1));
  do {
    *(b++) = "0123456789"[(i / x) % 10];
    x /= 10;
  } while (x > 0);
}

static void WriteHexDigits(CheckedIncrement<char*>& b, uintptr_t i) {
  int x = sizeof(intptr_t) * 8;
  bool wrote_msb = false;
  do {
    x -= 4;
    uintptr_t hex_digit = i >> x & 0xf;
    if (hex_digit || wrote_msb) {
      *(b++) = "0123456789abcdef"[hex_digit];
      wrote_msb = true;
    }
  } while (x > 0);
  if (!wrote_msb) {
    *(b++) = '0';
  }
}

int VSNPrintf(char* aBuf, size_t aSize, const char* aFormat, va_list aArgs) {
  CheckedIncrement<char*> b(aBuf, aSize);
  CheckedIncrement<const char*> f(aFormat, strlen(aFormat) + 1);
  while (true) {
    switch (*f) {
      case '\0':
        return b - aBuf;

      case '%': {
        // The start of the format specifier is used if this specifier is
        // invalid.
        const char* start = f;

        // Read the field width
        f++;
        char* end = nullptr;
        size_t width = strtoul(f, &end, 10);
        // If strtol can't find a number that's okay, that means 0 in our
        // case, but we must advance f).
        f.advance(end);

        switch (*f) {
          case 'z':
          case 'l':
          case 'u':
          case 'x': {
            size_t i;
            if (*f == 'z') {
              i = va_arg(aArgs, size_t);
              f++;
            } else if (*f == 'l') {
              i = size_t(va_arg(aArgs, unsigned long));
              f++;
            } else {
              i = size_t(va_arg(aArgs, unsigned));
            }

            if (*f == 'u') {
              size_t num_digits = NumDigits(i);
              LeftPad(b, width > num_digits ? width - num_digits : 0);
              WriteDigits(b, i, num_digits);
            } else if (*f == 'x') {
              WriteHexDigits(b, i);
            } else {
              // A length was combined with a format specifier that has no
              // lnegth.  Write out '%' and rewind to the beginning of the
              // specifier causing it to be printed normally.
              *(b++) = '%';
              f.rewind(start);
            }
            break;
          }

          case 'p': {
            intptr_t ptr = va_arg(aArgs, intptr_t);
            *(b++) = '0';
            *(b++) = 'x';
            WriteHexDigits(b, ptr);
            break;
          }

          case 's': {
            const char* str = va_arg(aArgs, const char*);
            size_t len = strlen(str);

            LeftPad(b, width > len ? width - len : 0);

            while (*str) {
              *(b++) = *(str++);
            }

            break;
          }

          case '%':
            // Print a single raw '%'.
            *(b++) = '%';
            break;

          default:
            // If the format specifier is unknown then write out '%' and
            // rewind to the beginning of the specifier causing it to be
            // printed normally.
            *(b++) = '%';
            f.rewind(start);
            break;
        }
        break;
      }
      default:
        *(b++) = *f;
        break;
    }
    f++;
  }
}

int SNPrintf(char* aBuf, size_t aSize, const char* aFormat, ...) {
  va_list args;
  va_start(args, aFormat);
  int ret = VSNPrintf(aBuf, aSize, aFormat, args);
  va_end(args);
  return ret;
}

void VFdPrintf(platform_handle_t aFd, const char* aFormat, va_list aArgs) {
  char buf[256];
  int len = VSNPrintf(buf, 256, aFormat, aArgs);
  FdPuts(aFd, buf, len);
}

void FdPrintf(platform_handle_t aFd, const char* aFormat, ...) {
  va_list args;
  va_start(args, aFormat);
  VFdPrintf(aFd, aFormat, args);
  va_end(args);
}

void FdPuts(platform_handle_t aFd, const char* aBuf, size_t aSize) {
  if (aFd == 0) {
    return;
  }

#ifdef _WIN32
  // See comment in FdPrintf.h as to why WriteFile is used.
  DWORD written;
  WriteFile(aFd, aBuf, aSize, &written, nullptr);
#else
  [[maybe_unused]] ssize_t _ = write(aFd, aBuf, aSize);
#endif
}