tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

Printf.h (8849B)

      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 /* Printf-like functions, with canned variants that malloc their result.  */
      8 
      9 #ifndef mozilla_Printf_h
     10 #define mozilla_Printf_h
     11 
     12 /*
     13 ** API for PR printf like routines.
     14 **
     15 ** These exist partly for historical reasons -- initially they were in
     16 ** NSPR, then forked in tree and modified in js/ -- but now the prime
     17 ** motivation is both closer control over the exact formatting (with
     18 ** one exception, see below) and also the ability to control where
     19 ** exactly the generated results are sent.
     20 **
     21 ** It might seem that this could all be dispensed with in favor of a
     22 ** wrapper around |vsnprintf| -- except that this implementation
     23 ** guarantees that the %s format will accept a NULL pointer, whereas
     24 ** with standard functions this is undefined.
     25 **
     26 ** This supports the following formats.  It implements a subset of the
     27 ** standard formats; due to the use of MOZ_FORMAT_PRINTF, it is not
     28 ** permissible to extend the standard, aside from relaxing undefined
     29 ** behavior.
     30 **
     31 **      %d - decimal
     32 **      %u - unsigned decimal
     33 **      %x - unsigned hex
     34 **      %X - unsigned uppercase hex
     35 **      %o - unsigned octal
     36 **      %hd, %hu, %hx, %hX, %ho - "short" versions of above
     37 **      %ld, %lu, %lx, %lX, %lo - "long" versions of above
     38 **      %lld, %llu, %llx, %llX, %llo - "long long" versions of above
     39 **      %zd, %zo, %zu, %zx, %zX - size_t versions of above
     40 **      %Id, %Io, %Iu, %Ix, %IX - size_t versions of above (for Windows compat).
     41 **           Note that MSVC 2015 and newer supports the z length modifier so
     42 **           users should prefer using %z instead of %I. We are supporting %I in
     43 **           addition to %z in case third-party code that uses %I gets routed to
     44 **           use this printf implementation.
     45 **      %s - string
     46 **      %S, %ls - wide string, that is wchar_t*
     47 **      %c - character
     48 **      %p - pointer (deals with machine dependent pointer size)
     49 **      %f - float; note that this is actually formatted using the
     50 **           system's native printf, and so the results may vary
     51 **      %g - float; note that this is actually formatted using the
     52 **           system's native printf, and so the results may vary
     53 */
     54 
     55 #include "mozilla/AllocPolicy.h"
     56 #include "mozilla/Assertions.h"
     57 #include "mozilla/Attributes.h"
     58 #include "mozilla/IntegerPrintfMacros.h"
     59 #include "mozilla/Types.h"
     60 #include "mozilla/UniquePtr.h"
     61 
     62 #include <stdarg.h>
     63 #include <string.h>
     64 
     65 namespace mozilla {
     66 
     67 /*
     68 * This class may be subclassed to provide a way to get the output of
     69 * a printf-like call, as the output is generated.
     70 */
     71 class PrintfTarget {
     72 public:
     73  /* The Printf-like interface.  */
     74  bool MFBT_API print(const char* format, ...) MOZ_FORMAT_PRINTF(2, 3);
     75 
     76  /* The Vprintf-like interface.  */
     77  bool MFBT_API vprint(const char* fmt, va_list) MOZ_FORMAT_PRINTF(2, 0);
     78 
     79  /* Fast paths for formatting integers as though by %d, %o, %u, or %x.
     80     Since octal and hex formatting always treat numbers as unsigned, there
     81     are no signed overloads for AppendInt{Oct,Hex}.  */
     82  bool MFBT_API appendIntDec(int32_t);
     83  bool MFBT_API appendIntDec(uint32_t);
     84  bool MFBT_API appendIntOct(uint32_t);
     85  bool MFBT_API appendIntHex(uint32_t);
     86  bool MFBT_API appendIntDec(int64_t);
     87  bool MFBT_API appendIntDec(uint64_t);
     88  bool MFBT_API appendIntOct(uint64_t);
     89  bool MFBT_API appendIntHex(uint64_t);
     90 
     91  inline size_t emitted() { return mEmitted; }
     92 
     93 protected:
     94  MFBT_API PrintfTarget();
     95  virtual ~PrintfTarget() = default;
     96 
     97  /* Subclasses override this.  It is called when more output is
     98     available.  It may be called with len==0.  This should return
     99     true on success, or false on failure.  */
    100  virtual bool append(const char* sp, size_t len) = 0;
    101 
    102 private:
    103  /* Number of bytes emitted so far.  */
    104  size_t mEmitted;
    105 
    106  /* The implementation calls this to emit bytes and update
    107     mEmitted.  */
    108  bool emit(const char* sp, size_t len) {
    109    mEmitted += len;
    110    return append(sp, len);
    111  }
    112 
    113  bool fill2(const char* src, int srclen, int width, int flags);
    114  bool fill_n(const char* src, int srclen, int width, int prec, int type,
    115              int flags);
    116  bool cvt_l(long num, int width, int prec, int radix, int type, int flags,
    117             const char* hexp);
    118  bool cvt_ll(int64_t num, int width, int prec, int radix, int type, int flags,
    119              const char* hexp);
    120  bool cvt_f(double d, char c, int width, int prec, int flags);
    121  bool cvt_s(const char* s, int width, int prec, int flags);
    122 };
    123 
    124 namespace detail {
    125 
    126 template <typename AllocPolicy = mozilla::MallocAllocPolicy>
    127 struct AllocPolicyBasedFreePolicy {
    128  void operator()(const void* ptr) {
    129    AllocPolicy policy;
    130    policy.free_(const_cast<void*>(ptr));
    131  }
    132 };
    133 
    134 }  // namespace detail
    135 
    136 // The type returned by Smprintf and friends.
    137 template <typename AllocPolicy>
    138 using SmprintfPolicyPointer =
    139    mozilla::UniquePtr<char, detail::AllocPolicyBasedFreePolicy<AllocPolicy>>;
    140 
    141 // The default type if no alloc policy is specified.
    142 typedef SmprintfPolicyPointer<mozilla::MallocAllocPolicy> SmprintfPointer;
    143 
    144 // Used in the implementation of Smprintf et al.
    145 template <typename AllocPolicy>
    146 class MOZ_STACK_CLASS SprintfState final : private mozilla::PrintfTarget,
    147                                           private AllocPolicy {
    148 public:
    149  explicit SprintfState(char* base)
    150      : mMaxlen(base ? strlen(base) : 0),
    151        mBase(base),
    152        mCur(base ? base + mMaxlen : 0) {}
    153 
    154  ~SprintfState() { this->free_(mBase); }
    155 
    156  bool vprint(const char* format, va_list ap_list) MOZ_FORMAT_PRINTF(2, 0) {
    157    // The "" here has a single \0 character, which is what we're
    158    // trying to append.
    159    return mozilla::PrintfTarget::vprint(format, ap_list) && append("", 1);
    160  }
    161 
    162  SmprintfPolicyPointer<AllocPolicy> release() {
    163    SmprintfPolicyPointer<AllocPolicy> result(mBase);
    164    mBase = nullptr;
    165    return result;
    166  }
    167 
    168 protected:
    169  bool append(const char* sp, size_t len) override {
    170    ptrdiff_t off;
    171    char* newbase;
    172    size_t newlen;
    173 
    174    off = mCur - mBase;
    175    if (off + len >= mMaxlen) {
    176      /* Grow the buffer */
    177      newlen = mMaxlen + ((len > 32) ? len : 32);
    178      newbase = this->template maybe_pod_malloc<char>(newlen);
    179      if (!newbase) {
    180        /* Ran out of memory */
    181        return false;
    182      }
    183      memcpy(newbase, mBase, mMaxlen);
    184      this->free_(mBase);
    185      mBase = newbase;
    186      mMaxlen = newlen;
    187      mCur = mBase + off;
    188    }
    189 
    190    /* Copy data */
    191    memcpy(mCur, sp, len);
    192    mCur += len;
    193    MOZ_ASSERT(size_t(mCur - mBase) <= mMaxlen);
    194    return true;
    195  }
    196 
    197 private:
    198  size_t mMaxlen;
    199  char* mBase;
    200  char* mCur;
    201 };
    202 
    203 /*
    204 ** sprintf into a malloc'd buffer. Return a pointer to the malloc'd
    205 ** buffer on success, nullptr on failure. Call AllocPolicy::free_ to release
    206 ** the memory returned.
    207 */
    208 template <typename AllocPolicy = mozilla::MallocAllocPolicy>
    209 MOZ_FORMAT_PRINTF(1, 2)
    210 SmprintfPolicyPointer<AllocPolicy> Smprintf(const char* fmt, ...) {
    211  SprintfState<AllocPolicy> ss(nullptr);
    212  va_list ap;
    213  va_start(ap, fmt);
    214  bool r = ss.vprint(fmt, ap);
    215  va_end(ap);
    216  if (!r) {
    217    return nullptr;
    218  }
    219  return ss.release();
    220 }
    221 
    222 /*
    223 ** "append" sprintf into a malloc'd buffer. "last" is the last value of
    224 ** the malloc'd buffer. sprintf will append data to the end of last,
    225 ** growing it as necessary using realloc. If last is nullptr, SmprintfAppend
    226 ** will allocate the initial string. The return value is the new value of
    227 ** last for subsequent calls, or nullptr if there is a malloc failure.
    228 */
    229 template <typename AllocPolicy = mozilla::MallocAllocPolicy>
    230 MOZ_FORMAT_PRINTF(2, 3)
    231 SmprintfPolicyPointer<AllocPolicy> SmprintfAppend(
    232    SmprintfPolicyPointer<AllocPolicy>&& last, const char* fmt, ...) {
    233  SprintfState<AllocPolicy> ss(last.release());
    234  va_list ap;
    235  va_start(ap, fmt);
    236  bool r = ss.vprint(fmt, ap);
    237  va_end(ap);
    238  if (!r) {
    239    return nullptr;
    240  }
    241  return ss.release();
    242 }
    243 
    244 /*
    245 ** va_list forms of the above.
    246 */
    247 template <typename AllocPolicy = mozilla::MallocAllocPolicy>
    248 MOZ_FORMAT_PRINTF(1, 0)
    249 SmprintfPolicyPointer<AllocPolicy> Vsmprintf(const char* fmt, va_list ap) {
    250  SprintfState<AllocPolicy> ss(nullptr);
    251  if (!ss.vprint(fmt, ap)) return nullptr;
    252  return ss.release();
    253 }
    254 
    255 template <typename AllocPolicy = mozilla::MallocAllocPolicy>
    256 MOZ_FORMAT_PRINTF(2, 0)
    257 SmprintfPolicyPointer<AllocPolicy> VsmprintfAppend(
    258    SmprintfPolicyPointer<AllocPolicy>&& last, const char* fmt, va_list ap) {
    259  SprintfState<AllocPolicy> ss(last.release());
    260  if (!ss.vprint(fmt, ap)) return nullptr;
    261  return ss.release();
    262 }
    263 
    264 }  // namespace mozilla
    265 
    266 #endif /* mozilla_Printf_h */