DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (7f9f804e9dbe)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
/* -*- 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/. */

/* Printf-like functions, with canned variants that malloc their result.  */

#ifndef mozilla_Printf_h
#define mozilla_Printf_h

/*
** API for PR printf like routines.
**
** These exist partly for historical reasons -- initially they were in
** NSPR, then forked in tree and modified in js/ -- but now the prime
** motivation is both closer control over the exact formatting (with
** one exception, see below) and also the ability to control where
** exactly the generated results are sent.
**
** It might seem that this could all be dispensed with in favor of a
** wrapper around |vsnprintf| -- except that this implementation
** guarantees that the %s format will accept a NULL pointer, whereas
** with standard functions this is undefined.
**
** This supports the following formats.  It implements a subset of the
** standard formats; due to the use of MOZ_FORMAT_PRINTF, it is not
** permissible to extend the standard, aside from relaxing undefined
** behavior.
**
**      %d - decimal
**      %u - unsigned decimal
**      %x - unsigned hex
**      %X - unsigned uppercase hex
**      %o - unsigned octal
**      %hd, %hu, %hx, %hX, %ho - "short" versions of above
**      %ld, %lu, %lx, %lX, %lo - "long" versions of above
**      %lld, %llu, %llx, %llX, %llo - "long long" versions of above
**      %zd, %zo, %zu, %zx, %zX - size_t versions of above
**      %Id, %Io, %Iu, %Ix, %IX - size_t versions of above (for Windows compat).
**           Note that MSVC 2015 and newer supports the z length modifier so
**           users should prefer using %z instead of %I. We are supporting %I in
**           addition to %z in case third-party code that uses %I gets routed to
**           use this printf implementation.
**      %s - string
**      %S, %ls - wide string, that is wchar_t*
**      %c - character
**      %p - pointer (deals with machine dependent pointer size)
**      %f - float; note that this is actually formatted using the
**           system's native printf, and so the results may vary
**      %g - float; note that this is actually formatted using the
**           system's native printf, and so the results may vary
*/

#include "mozilla/AllocPolicy.h"
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/IntegerPrintfMacros.h"
#include "mozilla/Types.h"
#include "mozilla/UniquePtr.h"

#include <stdarg.h>
#include <string.h>

namespace mozilla {

/*
 * This class may be subclassed to provide a way to get the output of
 * a printf-like call, as the output is generated.
 */
class PrintfTarget {
 public:
  /* The Printf-like interface.  */
  bool MFBT_API print(const char* format, ...) MOZ_FORMAT_PRINTF(2, 3);

  /* The Vprintf-like interface.  */
  bool MFBT_API vprint(const char* format, va_list) MOZ_FORMAT_PRINTF(2, 0);

  /* Fast paths for formatting integers as though by %d, %o, %u, or %x.
     Since octal and hex formatting always treat numbers as unsigned, there
     are no signed overloads for AppendInt{Oct,Hex}.  */
  bool MFBT_API appendIntDec(int32_t);
  bool MFBT_API appendIntDec(uint32_t);
  bool MFBT_API appendIntOct(uint32_t);
  bool MFBT_API appendIntHex(uint32_t);
  bool MFBT_API appendIntDec(int64_t);
  bool MFBT_API appendIntDec(uint64_t);
  bool MFBT_API appendIntOct(uint64_t);
  bool MFBT_API appendIntHex(uint64_t);

 protected:
  MFBT_API PrintfTarget();
  virtual ~PrintfTarget() = default;

  /* Subclasses override this.  It is called when more output is
     available.  It may be called with len==0.  This should return
     true on success, or false on failure.  */
  virtual bool append(const char* sp, size_t len) = 0;

 private:
  /* Number of bytes emitted so far.  */
  size_t mEmitted;

  /* The implementation calls this to emit bytes and update
     mEmitted.  */
  bool emit(const char* sp, size_t len) {
    mEmitted += len;
    return append(sp, len);
  }

  bool fill2(const char* src, int srclen, int width, int flags);
  bool fill_n(const char* src, int srclen, int width, int prec, int type,
              int flags);
  bool cvt_l(long num, int width, int prec, int radix, int type, int flags,
             const char* hxp);
  bool cvt_ll(int64_t num, int width, int prec, int radix, int type, int flags,
              const char* hexp);
  bool cvt_f(double d, const char* fmt0, const char* fmt1);
  bool cvt_s(const char* s, int width, int prec, int flags);
};

namespace detail {

template <typename AllocPolicy = mozilla::MallocAllocPolicy>
struct AllocPolicyBasedFreePolicy {
  void operator()(const void* ptr) {
    AllocPolicy policy;
    policy.free_(const_cast<void*>(ptr));
  }
};

}  // namespace detail

// The type returned by Smprintf and friends.
template <typename AllocPolicy>
using SmprintfPolicyPointer =
    mozilla::UniquePtr<char, detail::AllocPolicyBasedFreePolicy<AllocPolicy>>;

// The default type if no alloc policy is specified.
typedef SmprintfPolicyPointer<mozilla::MallocAllocPolicy> SmprintfPointer;

// Used in the implementation of Smprintf et al.
template <typename AllocPolicy>
class MOZ_STACK_CLASS SprintfState final : private mozilla::PrintfTarget,
                                           private AllocPolicy {
 public:
  explicit SprintfState(char* base)
      : mMaxlen(base ? strlen(base) : 0),
        mBase(base),
        mCur(base ? base + mMaxlen : 0) {}

  ~SprintfState() { this->free_(mBase); }

  bool vprint(const char* format, va_list ap_list) MOZ_FORMAT_PRINTF(2, 0) {
    // The "" here has a single \0 character, which is what we're
    // trying to append.
    return mozilla::PrintfTarget::vprint(format, ap_list) && append("", 1);
  }

  SmprintfPolicyPointer<AllocPolicy> release() {
    SmprintfPolicyPointer<AllocPolicy> result(mBase);
    mBase = nullptr;
    return result;
  }

 protected:
  bool append(const char* sp, size_t len) override {
    ptrdiff_t off;
    char* newbase;
    size_t newlen;

    off = mCur - mBase;
    if (off + len >= mMaxlen) {
      /* Grow the buffer */
      newlen = mMaxlen + ((len > 32) ? len : 32);
      newbase = this->template maybe_pod_malloc<char>(newlen);
      if (!newbase) {
        /* Ran out of memory */
        return false;
      }
      memcpy(newbase, mBase, mMaxlen);
      this->free_(mBase);
      mBase = newbase;
      mMaxlen = newlen;
      mCur = mBase + off;
    }

    /* Copy data */
    memcpy(mCur, sp, len);
    mCur += len;
    MOZ_ASSERT(size_t(mCur - mBase) <= mMaxlen);
    return true;
  }

 private:
  size_t mMaxlen;
  char* mBase;
  char* mCur;
};

/*
** sprintf into a malloc'd buffer. Return a pointer to the malloc'd
** buffer on success, nullptr on failure. Call AllocPolicy::free_ to release
** the memory returned.
*/
template <typename AllocPolicy = mozilla::MallocAllocPolicy>
MOZ_FORMAT_PRINTF(1, 2)
SmprintfPolicyPointer<AllocPolicy> Smprintf(const char* fmt, ...) {
  SprintfState<AllocPolicy> ss(nullptr);
  va_list ap;
  va_start(ap, fmt);
  bool r = ss.vprint(fmt, ap);
  va_end(ap);
  if (!r) {
    return nullptr;
  }
  return ss.release();
}

/*
** "append" sprintf into a malloc'd buffer. "last" is the last value of
** the malloc'd buffer. sprintf will append data to the end of last,
** growing it as necessary using realloc. If last is nullptr, SmprintfAppend
** will allocate the initial string. The return value is the new value of
** last for subsequent calls, or nullptr if there is a malloc failure.
*/
template <typename AllocPolicy = mozilla::MallocAllocPolicy>
MOZ_FORMAT_PRINTF(2, 3)
SmprintfPolicyPointer<AllocPolicy> SmprintfAppend(
    SmprintfPolicyPointer<AllocPolicy>&& last, const char* fmt, ...) {
  SprintfState<AllocPolicy> ss(last.release());
  va_list ap;
  va_start(ap, fmt);
  bool r = ss.vprint(fmt, ap);
  va_end(ap);
  if (!r) {
    return nullptr;
  }
  return ss.release();
}

/*
** va_list forms of the above.
*/
template <typename AllocPolicy = mozilla::MallocAllocPolicy>
MOZ_FORMAT_PRINTF(1, 0)
SmprintfPolicyPointer<AllocPolicy> Vsmprintf(const char* fmt, va_list ap) {
  SprintfState<AllocPolicy> ss(nullptr);
  if (!ss.vprint(fmt, ap)) return nullptr;
  return ss.release();
}

template <typename AllocPolicy = mozilla::MallocAllocPolicy>
MOZ_FORMAT_PRINTF(2, 0)
SmprintfPolicyPointer<AllocPolicy> VsmprintfAppend(
    SmprintfPolicyPointer<AllocPolicy>&& last, const char* fmt, va_list ap) {
  SprintfState<AllocPolicy> ss(last.release());
  if (!ss.vprint(fmt, ap)) return nullptr;
  return ss.release();
}

}  // namespace mozilla

#endif /* mozilla_Printf_h */