/* -*- 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 #include 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* fmt, 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); inline size_t emitted() { return mEmitted; } 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* hexp); bool cvt_ll(int64_t num, int width, int prec, int radix, int type, int flags, const char* hexp); bool cvt_f(double d, char c, int width, int prec, int flags); bool cvt_s(const char* s, int width, int prec, int flags); }; namespace detail { template struct AllocPolicyBasedFreePolicy { void operator()(const void* ptr) { AllocPolicy policy; policy.free_(const_cast(ptr)); } }; } // namespace detail // The type returned by Smprintf and friends. template using SmprintfPolicyPointer = mozilla::UniquePtr>; // The default type if no alloc policy is specified. typedef SmprintfPolicyPointer SmprintfPointer; // Used in the implementation of Smprintf et al. template 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 release() { SmprintfPolicyPointer 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(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 MOZ_FORMAT_PRINTF(1, 2) SmprintfPolicyPointer Smprintf(const char* fmt, ...) { SprintfState 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 MOZ_FORMAT_PRINTF(2, 3) SmprintfPolicyPointer SmprintfAppend( SmprintfPolicyPointer&& last, const char* fmt, ...) { SprintfState 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 MOZ_FORMAT_PRINTF(1, 0) SmprintfPolicyPointer Vsmprintf(const char* fmt, va_list ap) { SprintfState ss(nullptr); if (!ss.vprint(fmt, ap)) return nullptr; return ss.release(); } template MOZ_FORMAT_PRINTF(2, 0) SmprintfPolicyPointer VsmprintfAppend( SmprintfPolicyPointer&& last, const char* fmt, va_list ap) { SprintfState ss(last.release()); if (!ss.vprint(fmt, ap)) return nullptr; return ss.release(); } } // namespace mozilla #endif /* mozilla_Printf_h */