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 ";

// 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;

typedef fmt::internal::IntTraits<int>::MainType MainType;

MainType abs_value = static_cast<MainType>(error_code);

if (internal::is_negative(error_code)) {

abs_value = 0 - abs_value;

++error_code_size;

}

error_code_size += fmt::internal::count_digits(abs_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; }

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 = static_cast<UnsignedType>(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;

typedef typename fmt::internal::Conditional<

is_same<T, void>::value, U, T>::type TargetType;

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

// Extra casts are used to silence warnings.

if (is_signed) {

arg_.type = Arg::INT;

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

} else {

arg_.type = Arg::UINT;

typedef typename fmt::internal::MakeUnsigned<TargetType>::Type Unsigned;

arg_.uint_value = static_cast<unsigned>(static_cast<Unsigned>(value));

}

} else {

if (is_signed) {

arg_.type = Arg::LONG_LONG;

// glibc's printf doesn't sign extend arguments of smaller types:

// std::printf("%lld", -42); // prints "4294967254"

// but we don't have to do the same because it's a UB.

arg_.long_long_value = static_cast<fmt::LongLong>(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);

}

const char *data = w.data();

typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize;

UnsignedStreamSize size = w.size();

UnsignedStreamSize max_size =

internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());

do {

UnsignedStreamSize n = size <= max_size ? size : max_size;

os.write(data, static_cast<std::streamsize>(n));

data += n;

size -= n;

} while (size != 0);

public ArgFormatterBase<PrintfArgFormatter<Char>, Char> {

void write_null_pointer() {

this->spec().type_ = 0;

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

}

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

public:

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

: ArgFormatterBase<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);

}

int error_code, fmt::StringRef message) FMT_NOEXCEPT {

// 'fmt::' is for bcc32.

fmt::report_error(internal::format_system_error, error_code, message);

int error_code, fmt::StringRef message) FMT_NOEXCEPT {

// 'fmt::' is for bcc32.

fmt::report_error(internal::format_windows_error, error_code, message);

MemoryWriter w;

w.write(format_str, args);

std::fwrite(w.data(), 1, w.size(), f);

ArgList args) {

MemoryWriter w;

w.write(format_str, args);

write(os, w);

char escape[] = "\x1b[30m";

escape[3] = static_cast<char>('0' + c);

std::fputs(escape, stdout);

print(format, args);

std::fputs(RESET_COLOR, stdout);

MemoryWriter w;

printf(w, format, args);

std::size_t size = w.size();

return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);

MemoryWriter w;

printf(w, format, args);

write(os, w);

return static_cast<int>(w.size());