va_list args;

va_start(args, format);

int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);

va_end(args);

return result;

template <typename T>

static bool fits_in_int(T value) {

unsigned max = INT_MAX;

return value <= max;

}

static bool fits_in_int(bool) { return true; }

int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT {

FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer");

class StrError {

private:

int error_code_;

char *&buffer_;

std::size_t buffer_size_;

// A noop assignment operator to avoid bogus warnings.

void operator=(const StrError &) {}

// Handle the result of XSI-compliant version of strerror_r.

int handle(int result) {

// glibc versions before 2.13 return result in errno.

return result == -1 ? errno : result;

}

// Handle the result of GNU-specific version of strerror_r.

int handle(char *message) {

// If the buffer is full then the message is probably truncated.

if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)

return ERANGE;

buffer_ = message;

return 0;

}

// Handle the case when strerror_r is not available.

int handle(fmt::internal::Null<>) {

return fallback(strerror_s(buffer_, buffer_size_, error_code_));

}

// Fallback to strerror_s when strerror_r is not available.

int fallback(int result) {

// If the buffer is full then the message is probably truncated.

return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?

ERANGE : result;

}

// Fallback to strerror if strerror_r and strerror_s are not available.

int fallback(fmt::internal::Null<>) {

errno = 0;

buffer_ = strerror(error_code_);

return errno;

}

public:

StrError(int err_code, char *&buf, std::size_t buf_size)

: error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}

int run() {

strerror_r(0, 0, ""); // Suppress a warning about unused strerror_r.

return handle(strerror_r(error_code_, buffer_, buffer_size_));

}

};

return StrError(error_code, buffer, buffer_size).run();

fmt::StringRef message) FMT_NOEXCEPT {

// Report error code making sure that the output fits into

// INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential

// bad_alloc.

out.clear();

static const char SEP[] = ": ";

static const char ERROR_STR[] = "error ";

fmt::internal::IntTraits<int>::MainType ec_value = error_code;

// Subtract 2 to account for terminating null characters in SEP and ERROR_STR.

std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;

error_code_size += fmt::internal::count_digits(ec_value);

if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size)

out << message << SEP;

out << ERROR_STR << error_code;

assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE);

int error_code, fmt::StringRef message) FMT_NOEXCEPT {

fmt::MemoryWriter full_message;

func(full_message, error_code, message);

// Use Writer::data instead of Writer::c_str to avoid potential memory

// allocation.

std::fwrite(full_message.data(), full_message.size(), 1, stderr);

std::fputc('\n', stderr);

public:

template <typename T>

bool visit_any_int(T value) { return value == 0; }

assert('0' <= *s && *s <= '9');

unsigned value = 0;

do {

unsigned new_value = value * 10 + (*s++ - '0');

// Check if value wrapped around.

if (new_value < value) {

value = UINT_MAX;

break;

}

value = new_value;

} while ('0' <= *s && *s <= '9');

if (value > INT_MAX)

FMT_THROW(fmt::FormatError("number is too big"));

return value;

if (arg.type > Arg::LAST_NUMERIC_TYPE) {

std::string message =

fmt::format("format specifier '{}' requires numeric argument", spec);

FMT_THROW(fmt::FormatError(message));

}

char sign = static_cast<char>(*s);

require_numeric_argument(arg, sign);

if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {

FMT_THROW(fmt::FormatError(fmt::format(

"format specifier '{}' requires signed argument", sign)));

}

++s;

private:

fmt::FormatSpec &spec_;

FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);

public:

explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {}

void report_unhandled_arg() {

FMT_THROW(fmt::FormatError("width is not integer"));

}

template <typename T>

unsigned visit_any_int(T value) {

typedef typename fmt::internal::IntTraits<T>::MainType UnsignedType;

UnsignedType width = value;

if (fmt::internal::is_negative(value)) {

spec_.align_ = fmt::ALIGN_LEFT;

width = 0 - width;

}

if (width > INT_MAX)

FMT_THROW(fmt::FormatError("number is too big"));

return static_cast<unsigned>(width);

}

public fmt::internal::ArgVisitor<PrecisionHandler, int> {

public:

void report_unhandled_arg() {

FMT_THROW(fmt::FormatError("precision is not integer"));

}

template <typename T>

int visit_any_int(T value) {

if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))

FMT_THROW(fmt::FormatError("number is too big"));

return static_cast<int>(value);

}

private:

fmt::internal::Arg &arg_;

wchar_t type_;

FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);

public:

ArgConverter(fmt::internal::Arg &arg, wchar_t type)

: arg_(arg), type_(type) {}

void visit_bool(bool value) {

if (type_ != 's')

visit_any_int(value);

}

template <typename U>

void visit_any_int(U value) {

bool is_signed = type_ == 'd' || type_ == 'i';

using fmt::internal::Arg;

if (sizeof(T) <= sizeof(int)) {

// Extra casts are used to silence warnings.

if (is_signed) {

arg_.type = Arg::INT;

arg_.int_value = static_cast<int>(static_cast<T>(value));

} else {

arg_.type = Arg::UINT;

arg_.uint_value = static_cast<unsigned>(

static_cast<typename fmt::internal::MakeUnsigned<T>::Type>(value));

}

} else {

if (is_signed) {

arg_.type = Arg::LONG_LONG;

arg_.long_long_value =

static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);

} else {

arg_.type = Arg::ULONG_LONG;

arg_.ulong_long_value =

static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);

}

}

}

private:

fmt::internal::Arg &arg_;

FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);

public:

explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {}

template <typename T>

void visit_any_int(T value) {

arg_.type = Arg::CHAR;

arg_.int_value = static_cast<char>(value);

}

private:

BasicWriter<Char> &writer_;

FormatSpec &spec_;

FMT_DISALLOW_COPY_AND_ASSIGN(BasicArgFormatter);

void write_pointer(const void *p) {

spec_.flags_ = HASH_FLAG;

spec_.type_ = 'x';

writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);

}

protected:

BasicWriter<Char> &writer() { return writer_; }

FormatSpec &spec() { return spec_; }

void write(bool value) {

const char *str_value = value ? "true" : "false";

Arg::StringValue<char> str = { str_value, strlen(str_value) };

writer_.write_str(str, spec_);

}

void write(const char *value) {

Arg::StringValue<char> str = {value, value != 0 ? strlen(value) : 0};

writer_.write_str(str, spec_);

}

public:

BasicArgFormatter(BasicWriter<Char> &w, FormatSpec &s)

: writer_(w), spec_(s) {}

template <typename T>

void visit_any_int(T value) { writer_.write_int(value, spec_); }

template <typename T>

void visit_any_double(T value) { writer_.write_double(value, spec_); }

void visit_bool(bool value) {

if (spec_.type_)

return visit_any_int(value);

write(value);

}

void visit_char(int value) {

if (spec_.type_ && spec_.type_ != 'c') {

spec_.flags_ |= CHAR_FLAG;

writer_.write_int(value, spec_);

return;

}

if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)

FMT_THROW(FormatError("invalid format specifier for char"));

typedef typename BasicWriter<Char>::CharPtr CharPtr;

Char fill = internal::CharTraits<Char>::cast(spec_.fill());

CharPtr out = CharPtr();

const unsigned CHAR_WIDTH = 1;

if (spec_.width_ > CHAR_WIDTH) {

out = writer_.grow_buffer(spec_.width_);

if (spec_.align_ == ALIGN_RIGHT) {

std::fill_n(out, spec_.width_ - CHAR_WIDTH, fill);

out += spec_.width_ - CHAR_WIDTH;

} else if (spec_.align_ == ALIGN_CENTER) {

out = writer_.fill_padding(out, spec_.width_,

internal::check(CHAR_WIDTH), fill);

} else {

std::fill_n(out + CHAR_WIDTH, spec_.width_ - CHAR_WIDTH, fill);

}

} else {

out = writer_.grow_buffer(CHAR_WIDTH);

}

*out = internal::CharTraits<Char>::cast(value);

}

void visit_cstring(const char *value) {

if (spec_.type_ == 'p')

return write_pointer(value);

write(value);

}

void visit_string(Arg::StringValue<char> value) {

writer_.write_str(value, spec_);

}

using ArgVisitor<Impl, void>::visit_wstring;

void visit_wstring(Arg::StringValue<Char> value) {

writer_.write_str(value, spec_);

}

void visit_pointer(const void *value) {

if (spec_.type_ && spec_.type_ != 'p')

report_unknown_type(spec_.type_, "pointer");

write_pointer(value);

}

private:

BasicFormatter<Char> &formatter_;

const Char *format_;

public:

ArgFormatter(BasicFormatter<Char> &f, FormatSpec &s, const Char *fmt)

: BasicArgFormatter<ArgFormatter<Char>, Char>(f.writer(), s),

formatter_(f), format_(fmt) {}

void visit_custom(Arg::CustomValue c) {

c.format(&formatter_, c.value, &format_);

}

public BasicArgFormatter<PrintfArgFormatter<Char>, Char> {

void write_null_pointer() {

this->spec().type_ = 0;

this->write("(nil)");

}

typedef BasicArgFormatter<PrintfArgFormatter<Char>, Char> Base;

public:

PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)

: BasicArgFormatter<PrintfArgFormatter<Char>, Char>(w, s) {}

void visit_bool(bool value) {

FormatSpec &fmt_spec = this->spec();

if (fmt_spec.type_ != 's')

return this->visit_any_int(value);

fmt_spec.type_ = 0;

this->write(value);

}

void visit_char(int value) {

const FormatSpec &fmt_spec = this->spec();

BasicWriter<Char> &w = this->writer();

if (fmt_spec.type_ && fmt_spec.type_ != 'c')

w.write_int(value, fmt_spec);

typedef typename BasicWriter<Char>::CharPtr CharPtr;

CharPtr out = CharPtr();

if (fmt_spec.width_ > 1) {

Char fill = ' ';

out = w.grow_buffer(fmt_spec.width_);

if (fmt_spec.align_ != ALIGN_LEFT) {

std::fill_n(out, fmt_spec.width_ - 1, fill);

out += fmt_spec.width_ - 1;

} else {

std::fill_n(out + 1, fmt_spec.width_ - 1, fill);

}

} else {

out = w.grow_buffer(1);

}

*out = static_cast<Char>(value);

}

void visit_cstring(const char *value) {

if (value)

Base::visit_cstring(value);

else if (this->spec().type_ == 'p')

write_null_pointer();

else

this->write("(null)");

}

void visit_pointer(const void *value) {

if (value)

return Base::visit_pointer(value);

this->spec().type_ = 0;

write_null_pointer();

}

void visit_custom(Arg::CustomValue c) {

BasicFormatter<Char> formatter(ArgList(), this->writer());

const Char format_str[] = {'}', 0};

const Char *format = format_str;

c.format(&formatter, c.value, &format);

}

private:

LPWSTR str_;

public:

String() : str_() {}

~String() { LocalFree(str_); }

LPWSTR *ptr() { return &str_; }

LPCWSTR c_str() const { return str_; }