gecko-dev/mozglue/misc/Printf.h

270 строки
8.3 KiB
C++

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* vim: set ts=8 sts=4 et sw=4 tw=99:
* 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)
** You should use PRI*SIZE macros instead
** %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/SizePrintfMacros.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);
protected:
MFBT_API PrintfTarget();
virtual ~PrintfTarget() { }
/* 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));
}
};
}
// 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 = static_cast<char*>(this->maybe_pod_realloc(mBase, mMaxlen, newlen));
if (!newbase) {
/* Ran out of memory */
return false;
}
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();
}
/*
** Free the memory allocated, for the caller, by Smprintf.
*/
template<typename AllocPolicy = mozilla::MallocAllocPolicy>
void SmprintfFree(char* mem)
{
AllocPolicy allocator;
allocator.free_(mem);
}
} // namespace mozilla
#endif /* mozilla_Printf_h */