40 #if defined(_WIN32) && defined(__MINGW32__) 45 # if defined(NOMINMAX) || defined(FMT_WIN_MINMAX) 58 # define FMT_CATCH(x) catch (x) 60 # define FMT_TRY if (true) 61 # define FMT_CATCH(x) if (false) 65 # pragma warning(push) 66 # pragma warning(disable: 4127) // conditional expression is constant 67 # pragma warning(disable: 4702) // unreachable code 70 # pragma warning(disable: 4996) 91 # define FMT_SNPRINTF snprintf 93 inline int fmt_snprintf(
char *
buffer,
size_t size,
const char *
format, ...) {
95 va_start(args, format);
96 int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
100 # define FMT_SNPRINTF fmt_snprintf 103 #if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) 104 # define FMT_SWPRINTF snwprintf 106 # define FMT_SWPRINTF swprintf 107 #endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) 109 const char RESET_COLOR[] =
"\x1b[0m";
130 std::size_t buffer_size_;
133 void operator=(
const StrError &) {}
138 return result == -1 ? errno :
result;
144 if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
151 int handle(internal::Null<>) {
152 return fallback(
strerror_s(buffer_, buffer_size_, error_code_));
156 int fallback(
int result) {
158 return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
163 int fallback(internal::Null<>) {
165 buffer_ = strerror(error_code_);
170 StrError(
int err_code,
char *&
buf, std::size_t buf_size)
171 : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
175 return handle(
strerror_r(error_code_, buffer_, buffer_size_));
178 return StrError(error_code,
buffer, buffer_size).run();
181 void format_error_code(Writer &out,
int error_code,
187 static const char SEP[] =
": ";
188 static const char ERROR_STR[] =
"error ";
190 std::size_t error_code_size =
sizeof(SEP) +
sizeof(ERROR_STR) - 2;
191 typedef internal::IntTraits<int>::MainType MainType;
192 MainType abs_value =
static_cast<MainType
>(error_code);
194 abs_value = 0 - abs_value;
199 out << message << SEP;
200 out << ERROR_STR << error_code;
204 void report_error(FormatFunc func,
int error_code,
207 func(full_message, error_code, message);
210 std::fwrite(full_message.data(), full_message.size(), 1, stderr);
211 std::fputc(
'\n', stderr);
227 error_code_ = err_code;
230 std::runtime_error &base = *
this;
231 base = std::runtime_error(w.
str());
234 template <
typename T>
239 return precision < 0 ?
243 return precision < 0 ?
245 FMT_SNPRINTF(buffer, size, format, width, precision, value);
248 template <
typename T>
253 return precision < 0 ?
257 return precision < 0 ?
259 FMT_SWPRINTF(buffer, size, format, width, precision, value);
262 template <
typename T>
264 "0001020304050607080910111213141516171819" 265 "2021222324252627282930313233343536373839" 266 "4041424344454647484950515253545556575859" 267 "6061626364656667686970717273747576777879" 268 "8081828384858687888990919293949596979899";
270 #define FMT_POWERS_OF_10(factor) \ 278 factor * 100000000, \ 281 template <
typename T>
286 template <
typename T>
298 if (std::isprint(static_cast<unsigned char>(code))) {
300 format(
"unknown format code '{}' for {}", code, type)));
303 format(
"unknown format code '\\x{:02x}' for {}",
304 static_cast<unsigned>(code), type)));
307 #if FMT_USE_WINDOWS_H 310 static const char ERROR_MSG[] =
"cannot convert string from UTF-8 to UTF-16";
311 if (s.
size() > INT_MAX)
312 FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));
313 int s_size =
static_cast<int>(s.
size());
314 int length = MultiByteToWideChar(
315 CP_UTF8, MB_ERR_INVALID_CHARS, s.
data(), s_size, 0, 0);
317 FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
318 buffer_.resize(length + 1);
319 length = MultiByteToWideChar(
320 CP_UTF8, MB_ERR_INVALID_CHARS, s.
data(), s_size, &buffer_[0],
length);
322 FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
327 if (
int error_code =
convert(s)) {
329 "cannot convert string from UTF-16 to UTF-8"));
334 if (s.
size() > INT_MAX)
335 return ERROR_INVALID_PARAMETER;
336 int s_size =
static_cast<int>(s.
size());
337 int length = WideCharToMultiByte(CP_UTF8, 0, s.
data(), s_size, 0, 0, 0, 0);
339 return GetLastError();
340 buffer_.resize(length + 1);
341 length = WideCharToMultiByte(
342 CP_UTF8, 0, s.
data(), s_size, &buffer_[0],
length, 0, 0);
344 return GetLastError();
351 error_code_ = err_code;
353 internal::format_windows_error(w, err_code,
format(format_str, args));
354 std::runtime_error &base = *
this;
355 base = std::runtime_error(w.
str());
358 FMT_FUNC void internal::format_windows_error(
364 wchar_t *system_message = &buffer[0];
365 int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
366 0, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
367 system_message, static_cast<uint32_t>(buffer.
size()), 0);
369 UTF16ToUTF8 utf8_message;
370 if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
371 out << message <<
": " << utf8_message;
376 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
381 fmt::format_error_code(out, error_code, message);
384 #endif // FMT_USE_WINDOWS_H 392 char *system_message = &buffer[0];
393 int result = safe_strerror(error_code, system_message, buffer.
size());
395 out << message <<
": " << system_message;
398 if (result != ERANGE)
403 fmt::format_error_code(out, error_code, message);
406 template <
typename Char>
411 const NamedArg *named_arg = 0;
415 for (
unsigned i = 0;; ++i) {
421 named_arg =
static_cast<const NamedArg*
>(args.
values_[i].
pointer);
422 map_.push_back(
Pair(named_arg->
name, *named_arg));
433 named_arg =
static_cast<const NamedArg*
>(args.
args_[i].
pointer);
434 map_.push_back(
Pair(named_arg->
name, *named_arg));
442 named_arg =
static_cast<const NamedArg*
>(args.
args_[i].
pointer);
443 map_.push_back(
Pair(named_arg->
name, *named_arg));
451 template <
typename Char>
453 FMT_THROW(std::runtime_error(
"buffer overflow"));
457 unsigned arg_index,
const char *&error) {
458 Arg arg = args_[arg_index];
461 error =
"argument index out of range";
478 #if FMT_USE_WINDOWS_H 482 report_error(internal::format_windows_error, error_code, message);
488 w.
write(format_str, args);
493 print(stdout, format_str, args);
497 char escape[] =
"\x1b[30m";
498 escape[3] =
static_cast<char>(
'0' +
c);
499 std::fputs(escape, stdout);
501 std::fputs(RESET_COLOR, stdout);
504 template <
typename Char>
511 return std::fwrite(w.
data(), 1,
size,
f) < size ? -1 : static_cast<int>(size);
514 #ifndef FMT_HEADER_ONLY 527 char *
buffer, std::size_t
size,
const char *format,
530 template int internal::CharTraits<char>::format_float(
531 char *buffer, std::size_t size,
const char *format,
532 unsigned width,
int precision,
long double value);
543 wchar_t *buffer, std::size_t size,
const wchar_t *format,
544 unsigned width,
int precision,
double value);
546 template int internal::CharTraits<wchar_t>::format_float(
547 wchar_t *buffer, std::size_t size,
const wchar_t *format,
548 unsigned width,
int precision,
long double value);
550 #endif // FMT_HEADER_ONLY 555 # pragma warning(pop) GLsizei GLenum GLuint GLuint GLsizei GLchar * message
FMT_FUNC void print_colored(Color c, CStringRef format, ArgList args)
const internal::Arg * args_
bool is_negative(T value)
static const uint32_t POWERS_OF_10_32[]
BasicStringRef< Char > name
GLuint GLuint GLsizei GLenum type
FMT_API void report_unknown_type(char code, const char *type)
std::string format(CStringRef format_str, ArgList args)
const Char * data() const FMT_NOEXCEPT
FMT_GCC_EXTENSION typedef unsigned long long ULongLong
FMT_FUNC int fprintf(std::FILE *f, CStringRef format, ArgList args)
GLsizei const GLfloat * value
typedef void(GLAPIENTRY *PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target
FMT_FUNC void format_system_error(Writer &out, int error_code, StringRef message) FMT_NOEXCEPT
internal::Arg::Type type(unsigned index) const
GLuint GLsizei GLsizei * length
Yes & convert(fmt::ULongLong)
FMT_FUNC void report_system_error(int error_code, fmt::StringRef message) FMT_NOEXCEPT
FMT_FUNC void format_system_error(Writer &out, int error_code, StringRef message) FMT_NOEXCEPT
const Char * data() const
BasicStringRef< char > StringRef
BasicMemoryWriter< char > MemoryWriter
GLubyte GLubyte GLubyte GLubyte w
void write(BasicCStringRef< Char > format, ArgList args)
GLenum GLint GLint * precision
GLenum GLuint GLsizei const GLchar * buf
unsigned __int64 uint64_t
typedef int(WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
const internal::Value * values_
static const uint64_t POWERS_OF_10_64[]
internal::NamedArg< char > arg(StringRef name, const T &arg)
FMT_FUNC void print(std::FILE *f, CStringRef format_str, ArgList args)
unsigned count_digits(uint64_t n)
void resize(std::size_t new_size)
FMT_API void init(const ArgList &args)
GLint GLint GLint GLint GLint GLint GLsizei width
std::basic_string< Char > str() const
FMT_API void grow(std::size_t size)
void init(int err_code, CStringRef format_str, ArgList args)
void printf(BasicWriter< Char > &w, BasicCStringRef< Char > format, ArgList args)