From 2fe68db0a32137fe48014df2ce653f1e0a8ad93e Mon Sep 17 00:00:00 2001 From: gabime Date: Mon, 9 Feb 2015 23:47:51 +0200 Subject: [PATCH 01/60] pass nullptr to time() instead of 0 --- include/spdlog/details/os.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 67e64ecd..1fdc27b1 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -73,7 +73,7 @@ inline std::tm localtime(const std::time_t &time_tt) inline std::tm localtime() { - std::time_t now_t = time(0); + std::time_t now_t = time(nullptr); return localtime(now_t); } @@ -93,7 +93,7 @@ inline std::tm gmtime(const std::time_t &time_tt) inline std::tm gmtime() { - std::time_t now_t = time(0); + std::time_t now_t = time(nullptr); return gmtime(now_t); } inline bool operator==(const std::tm& tm1, const std::tm& tm2) From 147ce4c80dee3c693f19514ec331a9c07757eddd Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 10 Feb 2015 01:48:28 +0200 Subject: [PATCH 02/60] #define SPDLOG_NOEXCEPT throw() under visual studio --- include/spdlog/common.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/spdlog/common.h b/include/spdlog/common.h index 23c91947..8a6bfbf2 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -33,7 +33,7 @@ #ifndef _MSC_VER #define SPDLOG_NOEXCEPT noexcept #else -#define SPDLOG_NOEXCEPT +#define SPDLOG_NOEXCEPT throw() #endif // under linux, you can use the much faster CLOCK_REALTIME_COARSE clock. From 9f993da47221fca334833034fe22733d7f43cd49 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 10 Feb 2015 01:53:44 +0200 Subject: [PATCH 03/60] default move impl in async_msg --- include/spdlog/details/async_log_helper.h | 22 ++++++---------------- 1 file changed, 6 insertions(+), 16 deletions(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 8c04711f..4d8102a1 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -64,9 +64,14 @@ class async_log_helper async_msg() = default; ~async_msg() = default; + async_msg(async_msg&& other) = default; + async_msg& operator=(async_msg&& other) = default; + + // never copy or assign. should only be moved.. async_msg(const async_msg&) = delete; async_msg& operator=(async_msg& other) = delete; + // construct from log_msg async_msg(const details::log_msg& m) : logger_name(m.logger_name), level(m.level), @@ -74,23 +79,8 @@ class async_log_helper txt(m.raw.data(), m.raw.size()) {} - async_msg(async_msg&& other) : - logger_name(std::move(other.logger_name)), - level(std::move(other.level)), - time(std::move(other.time)), - txt(std::move(other.txt)) - {} - - async_msg& operator=(async_msg&& other) - { - logger_name = std::move(other.logger_name); - level = other.level; - time = std::move(other.time); - txt = std::move(other.txt); - return *this; - } - + // copy into log_msg void fill_log_msg(log_msg &msg) { msg.clear(); From fde3d2db99e9c6820d330635724c58cc5cfdb8c6 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 10 Feb 2015 01:56:09 +0200 Subject: [PATCH 04/60] astyle+comments --- bench/spdlog-async.cpp | 4 ++-- example/example.cpp | 9 ++++++--- include/spdlog/details/async_log_helper.h | 19 ++++++++++--------- .../spdlog/details/pattern_formatter_impl.h | 2 +- include/spdlog/spdlog.h | 4 ++-- 5 files changed, 21 insertions(+), 17 deletions(-) diff --git a/bench/spdlog-async.cpp b/bench/spdlog-async.cpp index 7307f39c..93a0ed07 100644 --- a/bench/spdlog-async.cpp +++ b/bench/spdlog-async.cpp @@ -19,9 +19,9 @@ int main(int argc, char* argv[]) int thread_count = 10; if(argc > 1) thread_count = atoi(argv[1]); - int howmany = 1000000; + int howmany = 10000001; - spd::set_async_mode(1048576); + spd::set_async_mode(1048576*16, spd::async_overflow_policy::discard_log_msg); auto logger = spdlog::create("file_logger", "logs/spd-bench-async.txt", false); logger->set_pattern("[%Y-%b-%d %T.%e]: %v"); diff --git a/example/example.cpp b/example/example.cpp index af76966e..44f6c0bf 100644 --- a/example/example.cpp +++ b/example/example.cpp @@ -37,7 +37,7 @@ int main(int, char* []) spd::set_level(spd::level::debug); // Create console, multithreaded logger - auto console = spd::stdout_logger_mt("console"); + auto console = spd::stdout_logger_mt("console"); console->info("Hello {}", 1); console->info("An info message example {}..", 1); console->info() << "Streams are supported too " << 1; @@ -65,7 +65,7 @@ int main(int, char* []) SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23); SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23); - + // Asynchronous logging is very fast.. // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous.. size_t q_size = 1048576; //queue size must be power of 2 @@ -94,7 +94,10 @@ int main(int, char* []) // Example of user defined class with operator<< // class some_class {}; -std::ostream& operator<<(std::ostream& os, const some_class&) { return os << "some_class"; } +std::ostream& operator<<(std::ostream& os, const some_class&) +{ + return os << "some_class"; +} void custom_class_example() { diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 4d8102a1..14628f1e 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -107,8 +107,9 @@ public: void log(const details::log_msg& msg); - //Stop logging and join the back thread + // stop logging and join the back thread ~async_log_helper(); + void set_formatter(formatter_ptr); @@ -137,11 +138,11 @@ private: // worker thread main loop void worker_loop(); - //pop next message from the queue and process it - //return true if a message was available (queue was not empty), will set the last_pop to the pop time + // pop next message from the queue and process it + // return true if a message was available (queue was not empty), will set the last_pop to the pop time bool process_next_msg(clock::time_point& last_pop); - // guess how much to sleep if queue is empty/full using last successful op time as hint + // sleep,yield or return immediatly using the time passed since last message as a hint static void sleep_or_yield(const clock::time_point& last_op_time); }; @@ -210,8 +211,8 @@ inline void spdlog::details::async_log_helper::worker_loop() } } -// Process next message in the queue -// Return true if this thread should still be active (no msg with level::off was received) +// process next message in the queue +// return true if this thread should still be active (no msg with level::off was received) inline bool spdlog::details::async_log_helper::process_next_msg(clock::time_point& last_pop) { @@ -243,7 +244,7 @@ inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_f } -// Sleep,yield or return immediatly using the time passed since last message as a hint +// sleep,yield or return immediatly using the time passed since last message as a hint inline void spdlog::details::async_log_helper::sleep_or_yield(const clock::time_point& last_op_time) { using std::chrono::milliseconds; @@ -251,7 +252,7 @@ inline void spdlog::details::async_log_helper::sleep_or_yield(const clock::time_ auto time_since_op = clock::now() - last_op_time; - //spin upto 1 ms + // spin upto 1 ms if (time_since_op <= milliseconds(1)) return; @@ -267,7 +268,7 @@ inline void spdlog::details::async_log_helper::sleep_or_yield(const clock::time_ return sleep_for(milliseconds(100)); } -//throw if the worker thread threw an exception or not active +// throw if the worker thread threw an exception or not active inline void spdlog::details::async_log_helper::throw_if_bad_worker() { if (_last_workerthread_ex) diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index b904d32d..e231b4d8 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -490,7 +490,7 @@ inline void spdlog::pattern_formatter::handle_flag(char flag) case 'L': _formatters.push_back(std::unique_ptr(new details::short_level_formatter())); break; - + case('t') : _formatters.push_back(std::unique_ptr(new details::t_formatter())); break; diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index 497a6f49..3af3ad57 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -55,7 +55,7 @@ void set_pattern(const std::string& format_string); void set_formatter(formatter_ptr f); // -// Set global logging level for +// Set global logging level for // void set_level(level::level_enum log_level); @@ -69,7 +69,7 @@ void set_level(level::level_enum log_level); // async_overflow_policy::block_retry - if queue is full, block until queue has room for the new log entry. // async_overflow_policy::discard_log_msg - never block and discard any new messages when queue overflows. // -// worker_warmup_cb (optional): +// worker_warmup_cb (optional): // callback function that will be called in worker thread upon start (can be used to init stuff like thread affinity) // void set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function& worker_warmup_cb = nullptr); From 405ff5100f33caf088e2a2ba5ce7c92ba0255b86 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 10 Feb 2015 02:02:28 +0200 Subject: [PATCH 05/60] fix bench --- bench/spdlog-async.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bench/spdlog-async.cpp b/bench/spdlog-async.cpp index 93a0ed07..7307f39c 100644 --- a/bench/spdlog-async.cpp +++ b/bench/spdlog-async.cpp @@ -19,9 +19,9 @@ int main(int argc, char* argv[]) int thread_count = 10; if(argc > 1) thread_count = atoi(argv[1]); - int howmany = 10000001; + int howmany = 1000000; - spd::set_async_mode(1048576*16, spd::async_overflow_policy::discard_log_msg); + spd::set_async_mode(1048576); auto logger = spdlog::create("file_logger", "logs/spd-bench-async.txt", false); logger->set_pattern("[%Y-%b-%d %T.%e]: %v"); From 9e54057aaa361e3b9cffc467f7fa316eb4bb2391 Mon Sep 17 00:00:00 2001 From: gabime Date: Thu, 12 Feb 2015 21:43:58 +0200 Subject: [PATCH 06/60] Bring back move implementation of async_msg move ctor and assignment since VS doesn't support it --- include/spdlog/details/async_log_helper.h | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 14628f1e..56804259 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -64,9 +64,21 @@ class async_log_helper async_msg() = default; ~async_msg() = default; - async_msg(async_msg&& other) = default; - async_msg& operator=(async_msg&& other) = default; + async_msg(async_msg&& other) SPDLOG_NOEXCEPT: + logger_name(std::move(other.logger_name)), + level(std::move(other.level)), + time(std::move(other.time)), + txt(std::move(other.txt)) + {} + async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT + { + logger_name = std::move(other.logger_name); + level = other.level; + time = std::move(other.time); + txt = std::move(other.txt); + return *this; + } // never copy or assign. should only be moved.. async_msg(const async_msg&) = delete; async_msg& operator=(async_msg& other) = delete; From c401e830d043e33fee0a823d98810874cc385d85 Mon Sep 17 00:00:00 2001 From: gabime Date: Sun, 15 Feb 2015 23:28:13 +0200 Subject: [PATCH 07/60] Added option for setting rotation time in daily file ctor --- include/spdlog/details/format.cc | 6 ++-- include/spdlog/details/spdlog_impl.h | 8 +++--- include/spdlog/sinks/file_sinks.h | 42 ++++++++++++++++++---------- include/spdlog/spdlog.h | 6 ++-- 4 files changed, 37 insertions(+), 25 deletions(-) diff --git a/include/spdlog/details/format.cc b/include/spdlog/details/format.cc index 5ca49bbc..08af20fb 100644 --- a/include/spdlog/details/format.cc +++ b/include/spdlog/details/format.cc @@ -642,11 +642,9 @@ FMT_FUNC void spdlog::details::fmt::BasicWriter::write_str( template inline Arg spdlog::details::fmt::BasicFormatter::parse_arg_index(const Char *&s) { const char *error = 0; - Arg arg = *s < '0' || *s > '9' ? - next_arg(error) : get_arg(parse_nonnegative_int(s), error); + Arg arg = *s < '0' || *s > '9' ? next_arg(error) : get_arg(parse_nonnegative_int(s), error); if (error) { - FMT_THROW(FormatError( - *s != '}' && *s != ':' ? "invalid format string" : error)); + FMT_THROW(FormatError(*s != '}' && *s != ':' ? "invalid format string" : error)); } return arg; } diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h index 69fb85d8..34805597 100644 --- a/include/spdlog/details/spdlog_impl.h +++ b/include/spdlog/details/spdlog_impl.h @@ -54,13 +54,13 @@ inline std::shared_ptr spdlog::rotating_logger_st(const std::str } // Create file logger which creates new file at midnight): -inline std::shared_ptr spdlog::daily_logger_mt(const std::string& logger_name, const std::string& filename, bool force_flush) +inline std::shared_ptr spdlog::daily_logger_mt(const std::string& logger_name, const std::string& filename, int hour, int minute, bool force_flush) { - return create(logger_name, filename, "txt", force_flush); + return create(logger_name, filename, "txt", hour, minute, force_flush); } -inline std::shared_ptr spdlog::daily_logger_st(const std::string& logger_name, const std::string& filename, bool force_flush) +inline std::shared_ptr spdlog::daily_logger_st(const std::string& logger_name, const std::string& filename, int hour, int minute, bool force_flush) { - return create(logger_name, filename, "txt", force_flush); + return create(logger_name, filename, "txt", hour, minute, force_flush); } diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index 0f73f5c5..dd463d54 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -155,14 +155,21 @@ template class daily_file_sink:public base_sink { public: - explicit daily_file_sink(const std::string& base_filename, - const std::string& extension, - bool force_flush=false): - _base_filename(base_filename), + //create daily file sink which rotates on given time + daily_file_sink( + const std::string& base_filename, + const std::string& extension, + int rotation_hour, + int rotation_minute, + bool force_flush=false): _base_filename(base_filename), _extension(extension), - _midnight_tp (_calc_midnight_tp() ), + _rotation_h(rotation_hour), + _rotation_m(rotation_minute), _file_helper(force_flush) { + if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59) + throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor"); + _rotation_tp = _next_rotation_tp(), _file_helper.open(calc_filename(_base_filename, _extension)); } @@ -170,26 +177,30 @@ public: protected: void _sink_it(const details::log_msg& msg) override { - if (std::chrono::system_clock::now() >= _midnight_tp) + if (std::chrono::system_clock::now() >= _rotation_tp) { _file_helper.close(); _file_helper.open(calc_filename(_base_filename, _extension)); - _midnight_tp = _calc_midnight_tp(); + _rotation_tp = _next_rotation_tp(); } _file_helper.write(msg); } private: - // Return next midnight's time_point - static std::chrono::system_clock::time_point _calc_midnight_tp() + std::chrono::system_clock::time_point _next_rotation_tp() { using namespace std::chrono; auto now = system_clock::now(); time_t tnow = std::chrono::system_clock::to_time_t(now); tm date = spdlog::details::os::localtime(tnow); - date.tm_hour = date.tm_min = date.tm_sec = 0; - auto midnight = std::chrono::system_clock::from_time_t(std::mktime(&date)); - return system_clock::time_point(midnight + hours(24)); + date.tm_hour = _rotation_h; + date.tm_min = _rotation_m; + date.tm_sec = 0; + auto rotation_time = std::chrono::system_clock::from_time_t(std::mktime(&date)); + if (rotation_time > now) + return rotation_time; + else + return system_clock::time_point(rotation_time + hours(24)); } //Create filename for the form basename.YYYY-MM-DD.extension @@ -197,15 +208,18 @@ private: { std::tm tm = spdlog::details::os::localtime(); details::fmt::MemoryWriter w; - w.write("{}.{:04d}-{:02d}-{:02d}.{}", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, extension); + w.write("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}.{}", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, extension); return w.str(); } std::string _base_filename; std::string _extension; - std::chrono::system_clock::time_point _midnight_tp; + int _rotation_h; + int _rotation_m; + std::chrono::system_clock::time_point _rotation_tp; details::file_helper _file_helper; + }; typedef daily_file_sink daily_file_sink_mt; diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index 3af3ad57..cd80a90c 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -84,10 +84,10 @@ std::shared_ptr rotating_logger_mt(const std::string& logger_name, const std::shared_ptr rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush = false); // -// Create file logger which creates new file at midnight): +// Create file logger which creates new file on the given time (default in midnight): // -std::shared_ptr daily_logger_mt(const std::string& logger_name, const std::string& filename, bool force_flush = false); -std::shared_ptr daily_logger_st(const std::string& logger_name, const std::string& filename, bool force_flush = false); +std::shared_ptr daily_logger_mt(const std::string& logger_name, const std::string& filename, int hour=0, int minute=0, bool force_flush = false); +std::shared_ptr daily_logger_st(const std::string& logger_name, const std::string& filename, int hour=0, int minute=0, bool force_flush = false); // From 9cfdfc75b7e146544890be487ba90a48e29cfcd0 Mon Sep 17 00:00:00 2001 From: gabime Date: Sun, 15 Feb 2015 23:35:55 +0200 Subject: [PATCH 08/60] Updated example to show daily logger usage --- README.md | 6 +++++ example/example.cpp | 53 ++++++++++++++++++++++++++++++--------------- 2 files changed, 41 insertions(+), 18 deletions(-) diff --git a/README.md b/README.md index 8d3e16f6..df165540 100644 --- a/README.md +++ b/README.md @@ -98,6 +98,12 @@ int main(int, char* []) for(int i = 0; i < 10; ++i) file_logger->info("{} * {} equals {:>10}", i, i, i*i); + + // + // Create a daily logger - a new file is created every day on 2:30am + // + auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily", 2, 30); + // // Customize msg format for all messages // diff --git a/example/example.cpp b/example/example.cpp index 44f6c0bf..e1dbffff 100644 --- a/example/example.cpp +++ b/example/example.cpp @@ -28,20 +28,18 @@ #include #include "spdlog/spdlog.h" -int main(int, char* []) +int main(int, char*[]) { namespace spd = spdlog; try { - // Set log level to all loggers to debug and above - spd::set_level(spd::level::debug); - - // Create console, multithreaded logger + //Create console, multithreaded logger auto console = spd::stdout_logger_mt("console"); - console->info("Hello {}", 1); + console->info("Welcome to spdlog!"); console->info("An info message example {}..", 1); console->info() << "Streams are supported too " << 1; + //Formatting examples console->info("Easy padding in numbers like {:08d}", 12); console->info("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); console->info("Support for floats {:03.2f}", 1.23456); @@ -51,37 +49,59 @@ int main(int, char* []) console->info("{:>30}", "right aligned"); console->info("{:^30}", "centered"); + // + // Runtime log levels + // + spd::set_level(spd::level::info); //Set global log level to info + console->debug("This message shold not be displayed!"); + console->set_level(spd::level::debug); // Set specific logger's log level + console->debug("Now it should.."); + + // // Create a file rotating logger with 5mb size max and 3 rotated files + // auto file_logger = spd::rotating_logger_mt("file_logger", "logs/mylogfile", 1048576 * 5, 3); - file_logger->set_level(spd::level::info); - for(int i = 0; i < 10; ++i) + for (int i = 0; i < 10; ++i) file_logger->info("{} * {} equals {:>10}", i, i, i*i); + + // + // Create a daily logger - a new file is created every day on 2:30am + // + auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily", 2, 30); + + // // Customize msg format for all messages + // spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***"); file_logger->info("This is another message with custom format"); spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function"); + // + // Compile time debug or trace macros. + // Enabled #ifdef SPDLOG_DEBUG_ON or #ifdef SPDLOG_TRACE_ON + // SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23); SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23); + // // Asynchronous logging is very fast.. // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous.. + // size_t q_size = 1048576; //queue size must be power of 2 spdlog::set_async_mode(q_size); - auto async_file= spd::daily_logger_st("async_file_logger", "logs/async_log.txt"); + auto async_file = spd::daily_logger_st("async_file_logger", "logs/async_log.txt"); async_file->info() << "This is async log.." << "Should be very fast!"; + // // syslog example. linux only.. + // #ifdef __linux__ std::string ident = "spdlog-example"; auto syslog_logger = spd::syslog_logger("syslog", ident, LOG_PID); syslog_logger->warn("This is warning that will end up in syslog. This is Linux only!"); #endif - - //Close all loggers - spd::drop_all(); } catch (const spd::spdlog_ex& ex) { @@ -90,19 +110,16 @@ int main(int, char* []) } -// // Example of user defined class with operator<< -// class some_class {}; -std::ostream& operator<<(std::ostream& os, const some_class&) -{ +std::ostream& operator<<(std::ostream& os, const some_class& c) { return os << "some_class"; } void custom_class_example() { some_class c; - spdlog::get("console")->info("custom class with operator<<: {}", c); - spdlog::get("console")->info() << "custom class with operator<<: " << c; + spdlog::get("console")->info("custom class with operator<<: {}..", c); + spdlog::get("console")->info() << "custom class with operator<<: " << c << ".."; } From abc4ccc513ddb5359fc035fd34a7f157076af81f Mon Sep 17 00:00:00 2001 From: gabime Date: Sun, 15 Feb 2015 23:40:45 +0200 Subject: [PATCH 09/60] Fix unused warning in example under gcc --- example/example.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/example/example.cpp b/example/example.cpp index e1dbffff..96226e32 100644 --- a/example/example.cpp +++ b/example/example.cpp @@ -112,7 +112,7 @@ int main(int, char*[]) // Example of user defined class with operator<< class some_class {}; -std::ostream& operator<<(std::ostream& os, const some_class& c) { +std::ostream& operator<<(std::ostream& os, const some_class&) { return os << "some_class"; } From 16224cc417662d79f718700cb8456aaee6c753ab Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Sun, 15 Feb 2015 23:43:59 +0200 Subject: [PATCH 10/60] Update README.md --- README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/README.md b/README.md index df165540..81b5feeb 100644 --- a/README.md +++ b/README.md @@ -73,7 +73,7 @@ int main(int, char* []) console->info("An info message example {}..", 1); console->info() << "Streams are supported too " << 1; - //Formatting examples + //Formatting examples console->info("Easy padding in numbers like {:08d}", 12); console->info("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); console->info("Support for floats {:03.2f}", 1.23456); @@ -98,7 +98,6 @@ int main(int, char* []) for(int i = 0; i < 10; ++i) file_logger->info("{} * {} equals {:>10}", i, i, i*i); - // // Create a daily logger - a new file is created every day on 2:30am // From 9c35a583272982a817cd6f59e9586e4e84461be3 Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Sun, 15 Feb 2015 23:44:47 +0200 Subject: [PATCH 11/60] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 81b5feeb..e72930b0 100644 --- a/README.md +++ b/README.md @@ -73,7 +73,7 @@ int main(int, char* []) console->info("An info message example {}..", 1); console->info() << "Streams are supported too " << 1; - //Formatting examples + //Formatting examples console->info("Easy padding in numbers like {:08d}", 12); console->info("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); console->info("Support for floats {:03.2f}", 1.23456); From c1dd340a251303222da33f803942356c127b77c8 Mon Sep 17 00:00:00 2001 From: gabime Date: Fri, 27 Feb 2015 11:24:10 +0200 Subject: [PATCH 12/60] Updated cppformat to version 86a7d856fa03fb5ba96f1a27907a4b7171f42e56 and remove spdlog::details namespace from it's source --- include/spdlog/details/format.cc | 331 ++--- include/spdlog/details/format.h | 1154 +++++++---------- .../spdlog/details/pattern_formatter_impl.h | 6 +- include/spdlog/sinks/file_sinks.h | 4 +- 4 files changed, 680 insertions(+), 815 deletions(-) diff --git a/include/spdlog/details/format.cc b/include/spdlog/details/format.cc index 08af20fb..0b7b5742 100644 --- a/include/spdlog/details/format.cc +++ b/include/spdlog/details/format.cc @@ -1,8 +1,5 @@ /* - -Modified version of cppformat formatting library - -Orginal license: +Formatting library for C++ Copyright (c) 2012 - 2014, Victor Zverovich All rights reserved. @@ -28,7 +25,7 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - +#include "format.h" #include @@ -39,18 +36,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #ifdef _WIN32 -# ifndef WIN32_LEAN_AND_MEAN -# define WIN32_LEAN_AND_MEAN -# endif # ifdef __MINGW32__ # include # endif # include #endif -using spdlog::details::fmt::LongLong; -using spdlog::details::fmt::ULongLong; -using spdlog::details::fmt::internal::Arg; +using fmt::internal::Arg; // Check if exceptions are disabled. #if __GNUC__ && !__EXCEPTIONS @@ -74,8 +66,10 @@ using spdlog::details::fmt::internal::Arg; #ifndef FMT_THROW # if FMT_EXCEPTIONS # define FMT_THROW(x) throw x +# define FMT_RETURN_AFTER_THROW(x) # else # define FMT_THROW(x) assert(false) +# define FMT_RETURN_AFTER_THROW(x) return x # endif #endif @@ -88,6 +82,7 @@ using spdlog::details::fmt::internal::Arg; #if _MSC_VER # pragma warning(push) # pragma warning(disable: 4127) // conditional expression is constant +# pragma warning(disable: 4702) // unreachable code #endif namespace { @@ -126,7 +121,7 @@ struct IntChecker { const char RESET_COLOR[] = "\x1b[0m"; -typedef void(*FormatFunc)(spdlog::details::fmt::Writer &, int, spdlog::details::fmt::StringRef); +typedef void(*FormatFunc)(fmt::Writer &, int, fmt::StringRef); // Portable thread-safe version of strerror. // Sets buffer to point to a string describing the error code. @@ -137,11 +132,17 @@ typedef void(*FormatFunc)(spdlog::details::fmt::Writer &, int, spdlog::details:: // ERANGE - buffer is not large enough to store the error message // other - failure // Buffer should be at least of size 1. -FMT_FUNC int safe_strerror( - int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT(true) { +int safe_strerror( + int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT{ assert(buffer != 0 && buffer_size != 0); int result = 0; -#ifdef _GNU_SOURCE +#if ((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && !_GNU_SOURCE) || __ANDROID__ + // XSI-compliant version of strerror_r. + result = strerror_r(error_code, buffer, buffer_size); + if (result != 0) + result = errno; +#elif _GNU_SOURCE + // GNU-specific version of strerror_r. char *message = strerror_r(error_code, buffer, buffer_size); // If the buffer is full then the message is probably truncated. if (message == buffer && strlen(buffer) == buffer_size - 1) @@ -165,27 +166,27 @@ FMT_FUNC int safe_strerror( return result; } -FMT_FUNC void format_error_code(spdlog::details::fmt::Writer &out, int error_code, - spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { +void format_error_code(fmt::Writer &out, int error_code, + 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 FMT_ERROR[] = "error "; - spdlog::details::fmt::internal::IntTraits::MainType ec_value = error_code; - // Subtract 2 to account for terminating null characters in SEP and FMT_ERROR. + static const char ERR[] = "error "; + fmt::internal::IntTraits::MainType ec_value = error_code; + // Subtract 2 to account for terminating null characters in SEP and ERR. std::size_t error_code_size = - sizeof(SEP) + sizeof(FMT_ERROR) + spdlog::details::fmt::internal::count_digits(ec_value) - 2; - if (message.size() <= spdlog::details::fmt::internal::INLINE_BUFFER_SIZE - error_code_size) + sizeof(SEP) + sizeof(ERR) + fmt::internal::count_digits(ec_value) - 2; + if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size) out << message << SEP; - out << FMT_ERROR << error_code; - assert(out.size() <= spdlog::details::fmt::internal::INLINE_BUFFER_SIZE); + out << ERR << error_code; + assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE); } -FMT_FUNC void report_error(FormatFunc func, - int error_code, spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { - spdlog::details::fmt::MemoryWriter full_message; +void report_error(FormatFunc func, + 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. @@ -194,7 +195,7 @@ FMT_FUNC void report_error(FormatFunc func, } // IsZeroInt::visit(arg) returns true iff arg is a zero integer. -class IsZeroInt : public spdlog::details::fmt::internal::ArgVisitor { +class IsZeroInt : public fmt::internal::ArgVisitor { public: template bool visit_any_int(T value) { @@ -205,7 +206,7 @@ public: // Parses an unsigned integer advancing s to the end of the parsed input. // This function assumes that the first character of s is a digit. template -FMT_FUNC int parse_nonnegative_int(const Char *&s) { +int parse_nonnegative_int(const Char *&s) { assert('0' <= *s && *s <= '9'); unsigned value = 0; do { @@ -218,88 +219,92 @@ FMT_FUNC int parse_nonnegative_int(const Char *&s) { value = new_value; } while ('0' <= *s && *s <= '9'); if (value > INT_MAX) - FMT_THROW(spdlog::details::fmt::FormatError("number is too big")); + FMT_THROW(fmt::FormatError("number is too big")); return value; } inline void require_numeric_argument(const Arg &arg, char spec) { if (arg.type > Arg::LAST_NUMERIC_TYPE) { std::string message = - spdlog::details::fmt::format("format specifier '{}' requires numeric argument", spec); - FMT_THROW(spdlog::details::fmt::FormatError(message)); + fmt::format("format specifier '{}' requires numeric argument", spec); + FMT_THROW(fmt::FormatError(message)); } } template -FMT_FUNC void check_sign(const Char *&s, const Arg &arg) { +void check_sign(const Char *&s, const Arg &arg) { char sign = static_cast(*s); require_numeric_argument(arg, sign); if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) { - FMT_THROW(spdlog::details::fmt::FormatError(spdlog::details::fmt::format( - "format specifier '{}' requires signed argument", sign))); + FMT_THROW(fmt::FormatError(fmt::format( + "format specifier '{}' requires signed argument", sign))); } ++s; } // Checks if an argument is a valid printf width specifier and sets // left alignment if it is negative. -class WidthHandler : public spdlog::details::fmt::internal::ArgVisitor { +class WidthHandler : public fmt::internal::ArgVisitor { private: - spdlog::details::fmt::FormatSpec &spec_; + fmt::FormatSpec &spec_; + + FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler); public: - explicit WidthHandler(spdlog::details::fmt::FormatSpec &spec) : spec_(spec) {} + explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {} unsigned visit_unhandled_arg() { - FMT_THROW(spdlog::details::fmt::FormatError("width is not integer")); - return 0; + FMT_THROW(fmt::FormatError("width is not integer")); + FMT_RETURN_AFTER_THROW(0); } template unsigned visit_any_int(T value) { - typedef typename spdlog::details::fmt::internal::IntTraits::MainType UnsignedType; + typedef typename fmt::internal::IntTraits::MainType UnsignedType; UnsignedType width = value; - if (spdlog::details::fmt::internal::is_negative(value)) { - spec_.align_ = spdlog::details::fmt::ALIGN_LEFT; + if (fmt::internal::is_negative(value)) { + spec_.align_ = fmt::ALIGN_LEFT; width = 0 - width; } if (width > INT_MAX) - FMT_THROW(spdlog::details::fmt::FormatError("number is too big")); + FMT_THROW(fmt::FormatError("number is too big")); return static_cast(width); } }; class PrecisionHandler : - public spdlog::details::fmt::internal::ArgVisitor { + public fmt::internal::ArgVisitor { public: unsigned visit_unhandled_arg() { - FMT_THROW(spdlog::details::fmt::FormatError("precision is not integer")); - return 0; + FMT_THROW(fmt::FormatError("precision is not integer")); + FMT_RETURN_AFTER_THROW(0); } template int visit_any_int(T value) { if (!IntChecker::is_signed>::fits_in_int(value)) - FMT_THROW(spdlog::details::fmt::FormatError("number is too big")); + FMT_THROW(fmt::FormatError("number is too big")); return static_cast(value); } }; // Converts an integer argument to an integral type T for printf. template -class ArgConverter : public spdlog::details::fmt::internal::ArgVisitor, void> { +class ArgConverter : public fmt::internal::ArgVisitor, void> { private: - spdlog::details::fmt::internal::Arg &arg_; + fmt::internal::Arg &arg_; wchar_t type_; + FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter); + public: - ArgConverter(spdlog::details::fmt::internal::Arg &arg, wchar_t type) + ArgConverter(fmt::internal::Arg &arg, wchar_t type) : arg_(arg), type_(type) {} template void visit_any_int(U value) { bool is_signed = type_ == 'd' || type_ == 'i'; - using spdlog::details::fmt::internal::Arg; + using fmt::internal::Arg; if (sizeof(T) <= sizeof(int)) { // Extra casts are used to silence warnings. if (is_signed) { @@ -309,31 +314,33 @@ public: else { arg_.type = Arg::UINT; arg_.uint_value = static_cast( - static_cast::Type>(value)); + static_cast::Type>(value)); } } else { if (is_signed) { arg_.type = Arg::LONG_LONG; arg_.long_long_value = - static_cast::Type>(value); + static_cast::Type>(value); } else { arg_.type = Arg::ULONG_LONG; arg_.ulong_long_value = - static_cast::Type>(value); + static_cast::Type>(value); } } } }; // Converts an integer argument to char for printf. -class CharConverter : public spdlog::details::fmt::internal::ArgVisitor { +class CharConverter : public fmt::internal::ArgVisitor { private: - spdlog::details::fmt::internal::Arg &arg_; + fmt::internal::Arg &arg_; + + FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter); public: - explicit CharConverter(spdlog::details::fmt::internal::Arg &arg) : arg_(arg) {} + explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {} template void visit_any_int(T value) { @@ -361,17 +368,17 @@ inline Arg::StringValue ignore_incompatible_str( } } // namespace -FMT_FUNC void spdlog::details::fmt::SystemError::init( - int error_code, StringRef format_str, ArgList args) { - error_code_ = error_code; +FMT_FUNC void fmt::SystemError::init( + int err_code, StringRef format_str, ArgList args) { + error_code_ = err_code; MemoryWriter w; - internal::format_system_error(w, error_code, format(format_str, args)); + internal::format_system_error(w, err_code, format(format_str, args)); std::runtime_error &base = *this; base = std::runtime_error(w.str()); } template -FMT_FUNC int spdlog::details::fmt::internal::CharTraits::format_float( +int fmt::internal::CharTraits::format_float( char *buffer, std::size_t size, const char *format, unsigned width, int precision, T value) { if (width == 0) { @@ -385,7 +392,7 @@ FMT_FUNC int spdlog::details::fmt::internal::CharTraits::format_float( } template -FMT_FUNC int spdlog::details::fmt::internal::CharTraits::format_float( +int fmt::internal::CharTraits::format_float( wchar_t *buffer, std::size_t size, const wchar_t *format, unsigned width, int precision, T value) { if (width == 0) { @@ -399,7 +406,7 @@ FMT_FUNC int spdlog::details::fmt::internal::CharTraits::format_float( } template -const char spdlog::details::fmt::internal::BasicData::DIGITS[] = +const char fmt::internal::BasicData::DIGITS[] = "0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" @@ -418,53 +425,53 @@ const char spdlog::details::fmt::internal::BasicData::DIGITS[] = factor * 1000000000 template -const uint32_t spdlog::details::fmt::internal::BasicData::POWERS_OF_10_32[] = { +const uint32_t fmt::internal::BasicData::POWERS_OF_10_32[] = { 0, FMT_POWERS_OF_10(1) }; template -const uint64_t spdlog::details::fmt::internal::BasicData::POWERS_OF_10_64[] = { +const uint64_t fmt::internal::BasicData::POWERS_OF_10_64[] = { 0, FMT_POWERS_OF_10(1), - FMT_POWERS_OF_10(ULongLong(1000000000)), + FMT_POWERS_OF_10(fmt::ULongLong(1000000000)), // Multiply several constants instead of using a single long long constant // to avoid warnings about C++98 not supporting long long. - ULongLong(1000000000) * ULongLong(1000000000) * 10 + fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10 }; -FMT_FUNC void spdlog::details::fmt::internal::report_unknown_type(char code, const char *type) { +FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type) { if (std::isprint(static_cast(code))) { - FMT_THROW(spdlog::details::fmt::FormatError( - spdlog::details::fmt::format("unknown format code '{}' for {}", code, type))); + FMT_THROW(fmt::FormatError( + fmt::format("unknown format code '{}' for {}", code, type))); } - FMT_THROW(spdlog::details::fmt::FormatError( - spdlog::details::fmt::format("unknown format code '\\x{:02x}' for {}", - static_cast(code), type))); + FMT_THROW(fmt::FormatError( + fmt::format("unknown format code '\\x{:02x}' for {}", + static_cast(code), type))); } #ifdef _WIN32 -FMT_FUNC spdlog::details::fmt::internal::UTF8ToUTF16::UTF8ToUTF16(spdlog::details::fmt::StringRef s) { +FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) { int length = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), -1, 0, 0); - static const char FMT_ERROR[] = "cannot convert string from UTF-8 to UTF-16"; + static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16"; if (length == 0) - FMT_THROW(WindowsError(GetLastError(), FMT_ERROR)); + FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); buffer_.resize(length); length = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), -1, &buffer_[0], length); if (length == 0) - FMT_THROW(WindowsError(GetLastError(), FMT_ERROR)); + FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); } -FMT_FUNC spdlog::details::fmt::internal::UTF16ToUTF8::UTF16ToUTF8(spdlog::details::fmt::WStringRef s) { +FMT_FUNC fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s) { if (int error_code = convert(s)) { FMT_THROW(WindowsError(error_code, "cannot convert string from UTF-16 to UTF-8")); } } -FMT_FUNC int spdlog::details::fmt::internal::UTF16ToUTF8::convert(spdlog::details::fmt::WStringRef s) { +FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) { int length = WideCharToMultiByte(CP_UTF8, 0, s.c_str(), -1, 0, 0, 0, 0); if (length == 0) return GetLastError(); @@ -476,21 +483,21 @@ FMT_FUNC int spdlog::details::fmt::internal::UTF16ToUTF8::convert(spdlog::detail return 0; } -FMT_FUNC void spdlog::details::fmt::WindowsError::init( - int error_code, StringRef format_str, ArgList args) { - error_code_ = error_code; +FMT_FUNC void fmt::WindowsError::init( + int err_code, StringRef format_str, ArgList args) { + error_code_ = err_code; MemoryWriter w; - internal::format_windows_error(w, error_code, format(format_str, args)); + internal::format_windows_error(w, err_code, format(format_str, args)); std::runtime_error &base = *this; base = std::runtime_error(w.str()); } #endif -FMT_FUNC void spdlog::details::fmt::internal::format_system_error( - spdlog::details::fmt::Writer &out, int error_code, - spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { - FMT_TRY { +FMT_FUNC void fmt::internal::format_system_error( + fmt::Writer &out, int error_code, + fmt::StringRef message) FMT_NOEXCEPT{ + FMT_TRY{ MemoryBuffer buffer; buffer.resize(INLINE_BUFFER_SIZE); for (;;) { @@ -509,9 +516,9 @@ FMT_FUNC void spdlog::details::fmt::internal::format_system_error( } #ifdef _WIN32 -FMT_FUNC void spdlog::details::fmt::internal::format_windows_error( - spdlog::details::fmt::Writer &out, int error_code, - spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { +FMT_FUNC void fmt::internal::format_windows_error( + fmt::Writer &out, int error_code, + fmt::StringRef message) FMT_NOEXCEPT{ class String { private: LPWSTR str_; @@ -524,11 +531,9 @@ FMT_FUNC void spdlog::details::fmt::internal::format_windows_error( LPWSTR *ptr() { return &str_; } - LPCWSTR c_str() const { - return str_; - } + LPCWSTR c_str() const { return str_; } }; - FMT_TRY { + FMT_TRY{ String system_message; if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0, @@ -547,17 +552,19 @@ FMT_FUNC void spdlog::details::fmt::internal::format_windows_error( // An argument formatter. template -class spdlog::details::fmt::internal::ArgFormatter : - public spdlog::details::fmt::internal::ArgVisitor, void> { +class fmt::internal::ArgFormatter : + public fmt::internal::ArgVisitor, void> { private: - spdlog::details::fmt::BasicFormatter &formatter_; - spdlog::details::fmt::BasicWriter &writer_; - spdlog::details::fmt::FormatSpec &spec_; + fmt::BasicFormatter &formatter_; + fmt::BasicWriter &writer_; + fmt::FormatSpec &spec_; const Char *format_; + FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatter); + public: ArgFormatter( - spdlog::details::fmt::BasicFormatter &f, spdlog::details::fmt::FormatSpec &s, const Char *fmt) + fmt::BasicFormatter &f, fmt::FormatSpec &s, const Char *fmt) : formatter_(f), writer_(f.writer()), spec_(s), format_(fmt) {} template @@ -578,16 +585,20 @@ public: } if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0) FMT_THROW(FormatError("invalid format specifier for char")); - typedef typename spdlog::details::fmt::BasicWriter::CharPtr CharPtr; + typedef typename fmt::BasicWriter::CharPtr CharPtr; + Char fill = static_cast(spec_.fill()); + if (spec_.precision_ == 0) { + std::fill_n(writer_.grow_buffer(spec_.width_), spec_.width_, fill); + return; + } CharPtr out = CharPtr(); if (spec_.width_ > 1) { - Char fill = static_cast(spec_.fill()); out = writer_.grow_buffer(spec_.width_); - if (spec_.align_ == spdlog::details::fmt::ALIGN_RIGHT) { + if (spec_.align_ == fmt::ALIGN_RIGHT) { std::fill_n(out, spec_.width_ - 1, fill); out += spec_.width_ - 1; } - else if (spec_.align_ == spdlog::details::fmt::ALIGN_CENTER) { + else if (spec_.align_ == fmt::ALIGN_CENTER) { out = writer_.fill_padding(out, spec_.width_, 1, fill); } else { @@ -609,8 +620,8 @@ public: void visit_pointer(const void *value) { if (spec_.type_ && spec_.type_ != 'p') - spdlog::details::fmt::internal::report_unknown_type(spec_.type_, "pointer"); - spec_.flags_ = spdlog::details::fmt::HASH_FLAG; + fmt::internal::report_unknown_type(spec_.type_, "pointer"); + spec_.flags_ = fmt::HASH_FLAG; spec_.type_ = 'x'; writer_.write_int(reinterpret_cast(value), spec_); } @@ -622,34 +633,39 @@ public: template template -FMT_FUNC void spdlog::details::fmt::BasicWriter::write_str( - const Arg::StringValue &str, const FormatSpec &spec) { +void fmt::BasicWriter::write_str( + const Arg::StringValue &s, const FormatSpec &spec) { // Check if StrChar is convertible to Char. internal::CharTraits::convert(StrChar()); if (spec.type_ && spec.type_ != 's') internal::report_unknown_type(spec.type_, "string"); - const StrChar *s = str.value; - std::size_t size = str.size; - if (size == 0) { - if (!s) + const StrChar *str_value = s.value; + std::size_t str_size = s.size; + if (str_size == 0) { + if (!str_value) FMT_THROW(FormatError("string pointer is null")); - if (*s) - size = std::char_traits::length(s); + if (*str_value) + str_size = std::char_traits::length(str_value); } - write_str(s, size, spec); + std::size_t precision = spec.precision_; + if (spec.precision_ >= 0 && precision < str_size) + str_size = spec.precision_; + write_str(str_value, str_size, spec); } template -inline Arg spdlog::details::fmt::BasicFormatter::parse_arg_index(const Char *&s) { +inline Arg fmt::BasicFormatter::parse_arg_index(const Char *&s) { const char *error = 0; - Arg arg = *s < '0' || *s > '9' ? next_arg(error) : get_arg(parse_nonnegative_int(s), error); + Arg arg = *s < '0' || *s > '9' ? + next_arg(error) : get_arg(parse_nonnegative_int(s), error); if (error) { - FMT_THROW(FormatError(*s != '}' && *s != ':' ? "invalid format string" : error)); + FMT_THROW(FormatError( + *s != '}' && *s != ':' ? "invalid format string" : error)); } return arg; } -FMT_FUNC Arg spdlog::details::fmt::internal::FormatterBase::do_get_arg( +FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg( unsigned arg_index, const char *&error) { Arg arg = args_[arg_index]; if (arg.type == Arg::NONE) @@ -657,14 +673,14 @@ FMT_FUNC Arg spdlog::details::fmt::internal::FormatterBase::do_get_arg( return arg; } -inline Arg spdlog::details::fmt::internal::FormatterBase::next_arg(const char *&error) { +inline Arg fmt::internal::FormatterBase::next_arg(const char *&error) { if (next_arg_index_ >= 0) return do_get_arg(next_arg_index_++, error); error = "cannot switch from manual to automatic argument indexing"; return Arg(); } -inline Arg spdlog::details::fmt::internal::FormatterBase::get_arg( +inline Arg fmt::internal::FormatterBase::get_arg( unsigned arg_index, const char *&error) { if (next_arg_index_ <= 0) { next_arg_index_ = -1; @@ -675,7 +691,7 @@ inline Arg spdlog::details::fmt::internal::FormatterBase::get_arg( } template -FMT_FUNC void spdlog::details::fmt::internal::PrintfFormatter::parse_flags( +void fmt::internal::PrintfFormatter::parse_flags( FormatSpec &spec, const Char *&s) { for (;;) { switch (*s++) { @@ -702,7 +718,7 @@ FMT_FUNC void spdlog::details::fmt::internal::PrintfFormatter::parse_flags } template -FMT_FUNC Arg spdlog::details::fmt::internal::PrintfFormatter::get_arg( +Arg fmt::internal::PrintfFormatter::get_arg( const Char *s, unsigned arg_index) { const char *error = 0; Arg arg = arg_index == UINT_MAX ? @@ -713,7 +729,7 @@ FMT_FUNC Arg spdlog::details::fmt::internal::PrintfFormatter::get_arg( } template -FMT_FUNC unsigned spdlog::details::fmt::internal::PrintfFormatter::parse_header( +unsigned fmt::internal::PrintfFormatter::parse_header( const Char *&s, FormatSpec &spec) { unsigned arg_index = UINT_MAX; Char c = *s; @@ -749,10 +765,10 @@ FMT_FUNC unsigned spdlog::details::fmt::internal::PrintfFormatter::parse_h } template -FMT_FUNC void spdlog::details::fmt::internal::PrintfFormatter::format( - BasicWriter &writer, BasicStringRef format, +void fmt::internal::PrintfFormatter::format( + BasicWriter &writer, BasicStringRef format_str, const ArgList &args) { - const Char *start = format.c_str(); + const Char *start = format_str.c_str(); set_args(args); const Char *s = start; while (*s) { @@ -803,7 +819,7 @@ FMT_FUNC void spdlog::details::fmt::internal::PrintfFormatter::format( break; case 'l': if (*s == 'l') - ArgConverter(arg, *++s).visit(arg); + ArgConverter(arg, *++s).visit(arg); else ArgConverter(arg, *s).visit(arg); break; @@ -907,8 +923,8 @@ FMT_FUNC void spdlog::details::fmt::internal::PrintfFormatter::format( case Arg::CUSTOM: { if (spec.type_) internal::report_unknown_type(spec.type_, "object"); - const void *s = "s"; - arg.custom.format(&writer, arg.custom.value, &s); + const void *str_format = "s"; + arg.custom.format(&writer, arg.custom.value, &str_format); break; } default: @@ -920,7 +936,7 @@ FMT_FUNC void spdlog::details::fmt::internal::PrintfFormatter::format( } template -FMT_FUNC const Char *spdlog::details::fmt::BasicFormatter::format( +const Char *fmt::BasicFormatter::format( const Char *&format_str, const Arg &arg) { const Char *s = format_str; FormatSpec spec; @@ -1039,9 +1055,10 @@ FMT_FUNC const Char *spdlog::details::fmt::BasicFormatter::format( else { FMT_THROW(FormatError("missing precision specifier")); } - if (arg.type != Arg::DOUBLE && arg.type != Arg::LONG_DOUBLE) { + if (arg.type < Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) { FMT_THROW(FormatError( - "precision specifier requires floating-point argument")); + fmt::format("precision not allowed in {} format specifier", + arg.type == Arg::POINTER ? "pointer" : "integer"))); } } @@ -1060,7 +1077,7 @@ FMT_FUNC const Char *spdlog::details::fmt::BasicFormatter::format( } template -FMT_FUNC void spdlog::details::fmt::BasicFormatter::format( +void fmt::BasicFormatter::format( BasicStringRef format_str, const ArgList &args) { const Char *s = start_ = format_str.c_str(); set_args(args); @@ -1081,35 +1098,35 @@ FMT_FUNC void spdlog::details::fmt::BasicFormatter::format( write(writer_, start_, s); } -FMT_FUNC void spdlog::details::fmt::report_system_error( - int error_code, spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { +FMT_FUNC void fmt::report_system_error( + int error_code, fmt::StringRef message) FMT_NOEXCEPT{ report_error(internal::format_system_error, error_code, message); } #ifdef _WIN32 -FMT_FUNC void spdlog::details::fmt::report_windows_error( - int error_code, spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { +FMT_FUNC void fmt::report_windows_error( + int error_code, fmt::StringRef message) FMT_NOEXCEPT{ report_error(internal::format_windows_error, error_code, message); } #endif -FMT_FUNC void spdlog::details::fmt::print(std::FILE *f, StringRef format_str, ArgList args) { +FMT_FUNC void fmt::print(std::FILE *f, StringRef format_str, ArgList args) { MemoryWriter w; w.write(format_str, args); std::fwrite(w.data(), 1, w.size(), f); } -FMT_FUNC void spdlog::details::fmt::print(StringRef format_str, ArgList args) { +FMT_FUNC void fmt::print(StringRef format_str, ArgList args) { print(stdout, format_str, args); } -FMT_FUNC void spdlog::details::fmt::print(std::ostream &os, StringRef format_str, ArgList args) { +FMT_FUNC void fmt::print(std::ostream &os, StringRef format_str, ArgList args) { MemoryWriter w; w.write(format_str, args); os.write(w.data(), w.size()); } -FMT_FUNC void spdlog::details::fmt::print_colored(Color c, StringRef format, ArgList args) { +FMT_FUNC void fmt::print_colored(Color c, StringRef format, ArgList args) { char escape[] = "\x1b[30m"; escape[3] = '0' + static_cast(c); std::fputs(escape, stdout); @@ -1117,7 +1134,7 @@ FMT_FUNC void spdlog::details::fmt::print_colored(Color c, StringRef format, Arg std::fputs(RESET_COLOR, stdout); } -FMT_FUNC int spdlog::details::fmt::fprintf(std::FILE *f, StringRef format, ArgList args) { +FMT_FUNC int fmt::fprintf(std::FILE *f, StringRef format, ArgList args) { MemoryWriter w; printf(w, format, args); std::size_t size = w.size(); @@ -1126,40 +1143,40 @@ FMT_FUNC int spdlog::details::fmt::fprintf(std::FILE *f, StringRef format, ArgLi // Explicit instantiations for char. -template const char *spdlog::details::fmt::BasicFormatter::format( - const char *&format_str, const spdlog::details::fmt::internal::Arg &arg); +template const char *fmt::BasicFormatter::format( + const char *&format_str, const fmt::internal::Arg &arg); -template void spdlog::details::fmt::BasicFormatter::format( +template void fmt::BasicFormatter::format( BasicStringRef format, const ArgList &args); -template void spdlog::details::fmt::internal::PrintfFormatter::format( +template void fmt::internal::PrintfFormatter::format( BasicWriter &writer, BasicStringRef format, const ArgList &args); -template int spdlog::details::fmt::internal::CharTraits::format_float( +template int fmt::internal::CharTraits::format_float( char *buffer, std::size_t size, const char *format, unsigned width, int precision, double value); -template int spdlog::details::fmt::internal::CharTraits::format_float( +template int fmt::internal::CharTraits::format_float( char *buffer, std::size_t size, const char *format, unsigned width, int precision, long double value); // Explicit instantiations for wchar_t. -template const wchar_t *spdlog::details::fmt::BasicFormatter::format( - const wchar_t *&format_str, const spdlog::details::fmt::internal::Arg &arg); +template const wchar_t *fmt::BasicFormatter::format( + const wchar_t *&format_str, const fmt::internal::Arg &arg); -template void spdlog::details::fmt::BasicFormatter::format( +template void fmt::BasicFormatter::format( BasicStringRef format, const ArgList &args); -template void spdlog::details::fmt::internal::PrintfFormatter::format( +template void fmt::internal::PrintfFormatter::format( BasicWriter &writer, BasicStringRef format, const ArgList &args); -template int spdlog::details::fmt::internal::CharTraits::format_float( +template int fmt::internal::CharTraits::format_float( wchar_t *buffer, std::size_t size, const wchar_t *format, unsigned width, int precision, double value); -template int spdlog::details::fmt::internal::CharTraits::format_float( +template int fmt::internal::CharTraits::format_float( wchar_t *buffer, std::size_t size, const wchar_t *format, unsigned width, int precision, long double value); diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h index 3934f812..334e8746 100644 --- a/include/spdlog/details/format.h +++ b/include/spdlog/details/format.h @@ -25,8 +25,10 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef SPDLOG_FMT_FORMAT_H_ -#define SPDLOG_FMT_FORMAT_H_ +#ifndef FMT_FORMAT_H_ +#define FMT_FORMAT_H_ + +#define FMT_HEADER_ONLY #include @@ -44,23 +46,65 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # include #endif -#ifdef __GNUC__ -// Ignore shadow warnings -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wshadow" +#ifdef _MSC_VER +# include // _BitScanReverse, _BitScanReverse64 +namespace fmt { +namespace internal { +# pragma intrinsic(_BitScanReverse) +inline uint32_t clz(uint32_t x) { + unsigned long r = 0; + _BitScanReverse(&r, x); + return 31 - r; +} +# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n) + +# ifdef _WIN64 +# pragma intrinsic(_BitScanReverse64) +# endif + +inline uint32_t clzll(uint64_t x) { + unsigned long r = 0; +# ifdef _WIN64 + _BitScanReverse64(&r, x); +# else + // Scan the high 32 bits. + if (_BitScanReverse(&r, static_cast(x >> 32))) + return 63 - (r + 32); + + // Scan the low 32 bits. + _BitScanReverse(&r, static_cast(x)); +# endif + return 63 - r; +} +# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n) +} +} +#endif + +#ifdef __GNUC__ # define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) # define FMT_GCC_EXTENSION __extension__ -// Disable warning about "long long" which is sometimes reported even -// when using __extension__. # if FMT_GCC_VERSION >= 406 # pragma GCC diagnostic push +// Disable the warning about "long long" which is sometimes reported even +// when using __extension__. # pragma GCC diagnostic ignored "-Wlong-long" +// Disable the warning about declaration shadowing because it affects too +// many valid cases. +# pragma GCC diagnostic ignored "-Wshadow" +# endif +# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__ +# define FMT_HAS_GXX_CXX11 1 # endif #else # define FMT_GCC_EXTENSION #endif +#ifdef __clang__ +# pragma clang diagnostic ignored "-Wdocumentation" +#endif + #ifdef __GNUC_LIBSTD__ # define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__) #endif @@ -77,13 +121,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # define FMT_HAS_BUILTIN(x) 0 #endif +#ifdef __has_cpp_attribute +# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) +#else +# define FMT_HAS_CPP_ATTRIBUTE(x) 0 +#endif + #ifndef FMT_USE_VARIADIC_TEMPLATES // Variadic templates are available in GCC since version 4.4 // (http://gcc.gnu.org/projects/cxx0x.html) and in Visual C++ // since version 2013. # define FMT_USE_VARIADIC_TEMPLATES \ (FMT_HAS_FEATURE(cxx_variadic_templates) || \ - (FMT_GCC_VERSION >= 404 && __cplusplus >= 201103) || _MSC_VER >= 1800) + (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1800) #endif #ifndef FMT_USE_RVALUE_REFERENCES @@ -94,7 +144,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # else # define FMT_USE_RVALUE_REFERENCES \ (FMT_HAS_FEATURE(cxx_rvalue_references) || \ - (FMT_GCC_VERSION >= 403 && __cplusplus >= 201103) || _MSC_VER >= 1600) + (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600) # endif #endif @@ -104,23 +154,26 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Define FMT_USE_NOEXCEPT to make C++ Format use noexcept (C++11 feature). #if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \ - (FMT_GCC_VERSION >= 408 && __cplusplus >= 201103) -# define FMT_NOEXCEPT(expr) noexcept(expr) + (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) +# define FMT_NOEXCEPT noexcept #else -# define FMT_NOEXCEPT(expr) +# define FMT_NOEXCEPT throw() #endif // A macro to disallow the copy constructor and operator= functions // This should be used in the private: declarations for a class -#define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \ - TypeName(const TypeName&); \ - void operator=(const TypeName&) -namespace spdlog -{ -namespace details -{ -namespace fmt -{ +#if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \ + (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1800 +# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \ + TypeName(const TypeName&) = delete; \ + TypeName& operator=(const TypeName&) = delete +#else +# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \ + TypeName(const TypeName&); \ + TypeName& operator=(const TypeName&) +#endif + +namespace fmt { // Fix the warning about long long on older versions of GCC // that don't support the diagnostic pragma. @@ -162,15 +215,14 @@ This class is most useful as a parameter type to allow passing different types of strings to a function, for example:: template -std::string format(StringRef format, const Args & ... args); +std::string format(StringRef format_str, const Args & ... args); format("{}", 42); format(std::string("{}"), 42); \endrst */ template -class BasicStringRef -{ +class BasicStringRef { private: const Char *data_; std::size_t size_; @@ -197,33 +249,28 @@ public: /** Converts a string reference to an `std::string` object. */ - operator std::basic_string() const - { + operator std::basic_string() const { return std::basic_string(data_, size()); } /** Returns the pointer to a C string. */ - const Char *c_str() const - { + const Char *c_str() const { return data_; } /** Returns the string size. */ - std::size_t size() const - { + std::size_t size() const { return size_; } - friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) - { + friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) { return lhs.data_ == rhs.data_; } - friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) - { + friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) { return lhs.data_ != rhs.data_; } }; @@ -234,15 +281,13 @@ typedef BasicStringRef WStringRef; /** A formatting error such as invalid format string. */ -class FormatError : public std::runtime_error -{ +class FormatError : public std::runtime_error { public: explicit FormatError(StringRef message) : std::runtime_error(message.c_str()) {} }; -namespace internal -{ +namespace internal { // The number of characters to store in the MemoryBuffer object itself // to avoid dynamic memory allocation. @@ -251,22 +296,19 @@ enum { INLINE_BUFFER_SIZE = 500 }; #if _SECURE_SCL // Use checked iterator to avoid warnings on MSVC. template -inline stdext::checked_array_iterator make_ptr(T *ptr, std::size_t size) -{ +inline stdext::checked_array_iterator make_ptr(T *ptr, std::size_t size) { return stdext::checked_array_iterator(ptr, size); } #else template -inline T *make_ptr(T *ptr, std::size_t) -{ +inline T *make_ptr(T *ptr, std::size_t) { return ptr; } #endif // A buffer for POD types. It supports a subset of std::vector's operations. template -class Buffer -{ +class Buffer { private: FMT_DISALLOW_COPY_AND_ASSIGN(Buffer); @@ -284,39 +326,31 @@ public: virtual ~Buffer() {} // Returns the size of this buffer. - std::size_t size() const - { + std::size_t size() const { return size_; } // Returns the capacity of this buffer. - std::size_t capacity() const - { + std::size_t capacity() const { return capacity_; } // Resizes the buffer. If T is a POD type new elements are not initialized. - void resize(std::size_t new_size) - { + void resize(std::size_t new_size) { if (new_size > capacity_) grow(new_size); size_ = new_size; } // Reserves space to store at least capacity elements. - void reserve(std::size_t capacity) - { + void reserve(std::size_t capacity) { if (capacity > capacity_) grow(capacity); } - void clear() FMT_NOEXCEPT(true) - { - size_ = 0; - } + void clear() FMT_NOEXCEPT{ size_ = 0; } - void push_back(const T &value) - { + void push_back(const T &value) { if (size_ == capacity_) grow(size_ + 1); ptr_[size_++] = value; @@ -325,19 +359,16 @@ public: // Appends data to the end of the buffer. void append(const T *begin, const T *end); - T &operator[](std::size_t index) - { + T &operator[](std::size_t index) { return ptr_[index]; } - const T &operator[](std::size_t index) const - { + const T &operator[](std::size_t index) const { return ptr_[index]; } }; template -void Buffer::append(const T *begin, const T *end) -{ +void Buffer::append(const T *begin, const T *end) { std::ptrdiff_t num_elements = end - begin; if (size_ + num_elements > capacity_) grow(size_ + num_elements); @@ -348,14 +379,12 @@ void Buffer::append(const T *begin, const T *end) // A memory buffer for POD types with the first SIZE elements stored in // the object itself. template > -class MemoryBuffer : private Allocator, public Buffer -{ +class MemoryBuffer : private Allocator, public Buffer { private: T data_[SIZE]; // Free memory allocated by the buffer. - void free() - { + void free() { if (this->ptr_ != data_) this->deallocate(this->ptr_, this->capacity_); } @@ -365,28 +394,24 @@ protected: public: explicit MemoryBuffer(const Allocator &alloc = Allocator()) : Allocator(alloc), Buffer(data_, SIZE) {} - ~MemoryBuffer() - { + ~MemoryBuffer() { free(); } #if FMT_USE_RVALUE_REFERENCES private: // Move data from other to this buffer. - void move(MemoryBuffer &other) - { + void move(MemoryBuffer &other) { Allocator &this_alloc = *this, &other_alloc = other; this_alloc = std::move(other_alloc); this->size_ = other.size_; this->capacity_ = other.capacity_; - if (other.ptr_ == other.data_) - { + if (other.ptr_ == other.data_) { this->ptr_ = data_; std::copy(other.data_, other.data_ + this->size_, make_ptr(data_, this->capacity_)); } - else - { + else { this->ptr_ = other.ptr_; // Set pointer to the inline array so that delete is not called // when freeing. @@ -395,13 +420,11 @@ private: } public: - MemoryBuffer(MemoryBuffer &&other) - { + MemoryBuffer(MemoryBuffer &&other) { move(other); } - MemoryBuffer &operator=(MemoryBuffer &&other) - { + MemoryBuffer &operator=(MemoryBuffer &&other) { assert(this != &other); free(); move(other); @@ -410,15 +433,13 @@ public: #endif // Returns a copy of the allocator associated with this buffer. - Allocator get_allocator() const - { + Allocator get_allocator() const { return *this; } }; template -void MemoryBuffer::grow(std::size_t size) -{ +void MemoryBuffer::grow(std::size_t size) { std::size_t new_capacity = (std::max)(size, this->capacity_ + this->capacity_ / 2); T *new_ptr = this->allocate(new_capacity); @@ -438,8 +459,7 @@ void MemoryBuffer::grow(std::size_t size) #ifndef _MSC_VER // Portable version of signbit. -inline int getsign(double x) -{ +inline int getsign(double x) { // When compiled in C++11 mode signbit is no longer a macro but a function // defined in namespace std and the macro is undefined. # ifdef signbit @@ -451,27 +471,22 @@ inline int getsign(double x) // Portable version of isinf. # ifdef isinf -inline int isinfinity(double x) -{ +inline int isinfinity(double x) { return isinf(x); } -inline int isinfinity(long double x) -{ +inline int isinfinity(long double x) { return isinf(x); } # else -inline int isinfinity(double x) -{ +inline int isinfinity(double x) { return std::isinf(x); } -inline int isinfinity(long double x) -{ +inline int isinfinity(long double x) { return std::isinf(x); } # endif #else -inline int getsign(double value) -{ +inline int getsign(double value) { if (value < 0) return 1; if (value == value) return 0; int dec = 0, sign = 0; @@ -479,27 +494,16 @@ inline int getsign(double value) _ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign); return sign; } -inline int isinfinity(double x) -{ +inline int isinfinity(double x) { return !_finite(x); } +inline int isinfinity(long double x) { + return !_finite(static_cast(x)); +} #endif -template -struct IsLongDouble -{ - enum { VALUE = 0 }; -}; - -template <> -struct IsLongDouble -{ - enum { VALUE = 1 }; -}; - template -class BasicCharTraits -{ +class BasicCharTraits { public: #if _SECURE_SCL typedef stdext::checked_array_iterator CharPtr; @@ -512,17 +516,13 @@ template class CharTraits; template <> -class CharTraits : public BasicCharTraits -{ +class CharTraits : public BasicCharTraits { private: // Conversion from wchar_t to char is not allowed. static char convert(wchar_t); public: - typedef const wchar_t *UnsupportedStrType; - - static char convert(char value) - { + static char convert(char value) { return value; } @@ -533,17 +533,12 @@ public: }; template <> -class CharTraits : public BasicCharTraits -{ +class CharTraits : public BasicCharTraits { public: - typedef const char *UnsupportedStrType; - - static wchar_t convert(char value) - { + static wchar_t convert(char value) { return value; } - static wchar_t convert(wchar_t value) - { + static wchar_t convert(wchar_t value) { return value; } @@ -554,21 +549,17 @@ public: // Checks if a number is negative - used to avoid warnings. template -struct SignChecker -{ +struct SignChecker { template - static bool is_negative(T value) - { + static bool is_negative(T value) { return value < 0; } }; template <> -struct SignChecker -{ +struct SignChecker { template - static bool is_negative(T) - { + static bool is_negative(T) { return false; } }; @@ -576,27 +567,23 @@ struct SignChecker // Returns true if value is negative, false otherwise. // Same as (value < 0) but doesn't produce warnings if T is an unsigned type. template -inline bool is_negative(T value) -{ +inline bool is_negative(T value) { return SignChecker::is_signed>::is_negative(value); } // Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise. template -struct TypeSelector -{ +struct TypeSelector { typedef uint32_t Type; }; template <> -struct TypeSelector -{ +struct TypeSelector { typedef uint64_t Type; }; template -struct IntTraits -{ +struct IntTraits { // Smallest of uint32_t and uint64_t that is large enough to represent // all values of T. typedef typename @@ -605,8 +592,7 @@ struct IntTraits // MakeUnsigned::Type gives an unsigned type corresponding to integer type T. template -struct MakeUnsigned -{ +struct MakeUnsigned { typedef T Type; }; @@ -626,8 +612,7 @@ void report_unknown_type(char code, const char *type); // Static data is placed in this class template to allow header-only // configuration. template -struct BasicData -{ +struct BasicData { static const uint32_t POWERS_OF_10_32[]; static const uint64_t POWERS_OF_10_64[]; static const char DIGITS[]; @@ -635,31 +620,28 @@ struct BasicData typedef BasicData<> Data; +#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz) +# define FMT_BUILTIN_CLZ(n) __builtin_clz(n) +#endif + #if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll) +# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) +#endif + +#ifdef FMT_BUILTIN_CLZLL // Returns the number of decimal digits in n. Leading zeros are not counted // except for n == 0 in which case count_digits returns 1. -inline unsigned count_digits(uint64_t n) -{ +inline unsigned count_digits(uint64_t n) { // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. - unsigned t = (64 - __builtin_clzll(n | 1)) * 1233 >> 12; + unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; return t - (n < Data::POWERS_OF_10_64[t]) + 1; } -# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz) -// Optional version of count_digits for better performance on 32-bit platforms. -inline unsigned count_digits(uint32_t n) -{ - uint32_t t = (32 - __builtin_clz(n | 1)) * 1233 >> 12; - return t - (n < Data::POWERS_OF_10_32[t]) + 1; -} -# endif #else // Fallback version of count_digits used when __builtin_clz is not available. -inline unsigned count_digits(uint64_t n) -{ +inline unsigned count_digits(uint64_t n) { unsigned count = 1; - for (;;) - { + for (;;) { // Integer division is slow so do it for a group of four digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. @@ -673,13 +655,19 @@ inline unsigned count_digits(uint64_t n) } #endif +#ifdef FMT_BUILTIN_CLZ +// Optional version of count_digits for better performance on 32-bit platforms. +inline unsigned count_digits(uint32_t n) { + uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; + return t - (n < Data::POWERS_OF_10_32[t]) + 1; +} +#endif + // Formats a decimal unsigned integer value writing into buffer. template -inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) -{ +inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { --num_digits; - while (value >= 100) - { + while (value >= 100) { // Integer division is slow so do it for a group of two digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. @@ -689,8 +677,7 @@ inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) buffer[num_digits - 1] = Data::DIGITS[index]; num_digits -= 2; } - if (value < 10) - { + if (value < 10) { *buffer = static_cast('0' + value); return; } @@ -702,55 +689,45 @@ inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) #ifdef _WIN32 // A converter from UTF-8 to UTF-16. // It is only provided for Windows since other systems support UTF-8 natively. -class UTF8ToUTF16 -{ +class UTF8ToUTF16 { private: MemoryBuffer buffer_; public: explicit UTF8ToUTF16(StringRef s); - operator WStringRef() const - { + operator WStringRef() const { return WStringRef(&buffer_[0], size()); } - size_t size() const - { + size_t size() const { return buffer_.size() - 1; } - const wchar_t *c_str() const - { + const wchar_t *c_str() const { return &buffer_[0]; } - std::wstring str() const - { + std::wstring str() const { return std::wstring(&buffer_[0], size()); } }; // A converter from UTF-16 to UTF-8. // It is only provided for Windows since other systems support UTF-8 natively. -class UTF16ToUTF8 -{ +class UTF16ToUTF8 { private: MemoryBuffer buffer_; public: UTF16ToUTF8() {} explicit UTF16ToUTF8(WStringRef s); - operator StringRef() const - { + operator StringRef() const { return StringRef(&buffer_[0], size()); } - size_t size() const - { + size_t size() const { return buffer_.size() - 1; } - const char *c_str() const - { + const char *c_str() const { return &buffer_[0]; } - std::string str() const - { + std::string str() const { return std::string(&buffer_[0], size()); } @@ -762,34 +739,30 @@ public: #endif void format_system_error(fmt::Writer &out, int error_code, - fmt::StringRef message) FMT_NOEXCEPT(true); + fmt::StringRef message) FMT_NOEXCEPT; #ifdef _WIN32 void format_windows_error(fmt::Writer &out, int error_code, - fmt::StringRef message) FMT_NOEXCEPT(true); + fmt::StringRef message) FMT_NOEXCEPT; #endif // Computes max(Arg, 1) at compile time. It is used to avoid errors about // allocating an array of 0 size. template -struct NonZero -{ +struct NonZero { enum { VALUE = Arg }; }; template <> -struct NonZero<0> -{ +struct NonZero<0> { enum { VALUE = 1 }; }; // The value of a formatting argument. It is a POD type to allow storage in // internal::MemoryBuffer. -struct Value -{ +struct Value { template - struct StringValue - { + struct StringValue { const Char *value; std::size_t size; }; @@ -797,14 +770,12 @@ struct Value typedef void(*FormatFunc)( void *formatter, const void *arg, void *format_str_ptr); - struct CustomValue - { + struct CustomValue { const void *value; FormatFunc format; }; - union - { + union { int int_value; unsigned uint_value; LongLong long_long_value; @@ -820,10 +791,8 @@ struct Value }; }; -struct Arg : Value -{ - enum Type - { +struct Arg : Value { + enum Type { NONE, // Integer types should go first, INT, UINT, LONG_LONG, ULONG_LONG, CHAR, LAST_INTEGER_TYPE = CHAR, @@ -834,10 +803,26 @@ struct Arg : Value Type type; }; +template +struct None {}; + +// A helper class template to enable or disable overloads taking wide +// characters and strings in MakeValue. +template +struct WCharHelper { + typedef None Supported; + typedef T Unsupported; +}; + +template +struct WCharHelper { + typedef T Supported; + typedef None Unsupported; +}; + // Makes a Value object from any type. template -class MakeValue : public Value -{ +class MakeValue : public Value { private: // The following two methods are private to disallow formatting of // arbitrary pointers. If you want to output a pointer cast it to @@ -849,15 +834,22 @@ private: template MakeValue(T *value); - void set_string(StringRef str) - { + // The following methods are private to disallow formatting of wide + // characters and strings into narrow strings as in + // fmt::format("{}", L"test"); + // To fix this, use a wide format string: fmt::format(L"{}", L"test"). + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + + void set_string(StringRef str) { string.value = str.c_str(); string.size = str.size(); } - void set_string(WStringRef str) - { - CharTraits::convert(wchar_t()); + void set_string(WStringRef str) { wstring.value = str.c_str(); wstring.size = str.size(); } @@ -865,8 +857,7 @@ private: // Formats an argument of a custom type, such as a user-defined class. template static void format_custom_arg( - void *formatter, const void *arg, void *format_str_ptr) - { + void *formatter, const void *arg, void *format_str_ptr) { format(*static_cast*>(formatter), *static_cast(format_str_ptr), *static_cast(arg)); @@ -885,8 +876,7 @@ public: FMT_MAKE_VALUE(int, int_value, INT) FMT_MAKE_VALUE(unsigned, uint_value, UINT) - MakeValue(long value) - { + MakeValue(long value) { // To minimize the number of types we need to deal with, long is // translated either to int or to long long depending on its size. if (sizeof(long) == sizeof(int)) @@ -894,20 +884,17 @@ public: else long_long_value = value; } - static uint64_t type(long) - { + static uint64_t type(long) { return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG; } - MakeValue(unsigned long value) - { + MakeValue(unsigned long value) { if (sizeof(unsigned long) == sizeof(unsigned)) uint_value = static_cast(value); else ulong_long_value = value; } - static uint64_t type(unsigned long) - { + static uint64_t type(unsigned long) { return sizeof(unsigned long) == sizeof(unsigned) ? Arg::UINT : Arg::ULONG_LONG; } @@ -921,12 +908,10 @@ public: FMT_MAKE_VALUE(unsigned char, int_value, CHAR) FMT_MAKE_VALUE(char, int_value, CHAR) - MakeValue(wchar_t value) - { - int_value = internal::CharTraits::convert(value); + MakeValue(typename WCharHelper::Supported value) { + int_value = value; } - static uint64_t type(wchar_t) - { + static uint64_t type(wchar_t) { return Arg::CHAR; } @@ -941,23 +926,27 @@ public: FMT_MAKE_STR_VALUE(const std::string &, STRING) FMT_MAKE_STR_VALUE(StringRef, STRING) - FMT_MAKE_STR_VALUE(wchar_t *, WSTRING) - FMT_MAKE_STR_VALUE(const wchar_t *, WSTRING) - FMT_MAKE_STR_VALUE(const std::wstring &, WSTRING) - FMT_MAKE_STR_VALUE(WStringRef, WSTRING) +#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \ + MakeValue(typename WCharHelper::Supported value) { \ + set_string(value); \ + } \ + static uint64_t type(Type) { return Arg::TYPE; } + + FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING) + FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING) + FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING) + FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING) FMT_MAKE_VALUE(void *, pointer, POINTER) FMT_MAKE_VALUE(const void *, pointer, POINTER) template - MakeValue(const T &value) - { + MakeValue(const T &value) { custom.value = &value; custom.format = &format_custom_arg; } template - static uint64_t type(const T &) - { + static uint64_t type(const T &) { return Arg::CUSTOM; } }; @@ -985,78 +974,61 @@ public: // ArgVisitor uses the curiously recurring template pattern: // http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern template -class ArgVisitor -{ +class ArgVisitor { public: - Result visit_unhandled_arg() - { + Result visit_unhandled_arg() { return Result(); } - Result visit_int(int value) - { + Result visit_int(int value) { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_long_long(LongLong value) - { + Result visit_long_long(LongLong value) { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_uint(unsigned value) - { + Result visit_uint(unsigned value) { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_ulong_long(ULongLong value) - { + Result visit_ulong_long(ULongLong value) { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_char(int value) - { + Result visit_char(int value) { return FMT_DISPATCH(visit_any_int(value)); } template - Result visit_any_int(T) - { + Result visit_any_int(T) { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_double(double value) - { + Result visit_double(double value) { return FMT_DISPATCH(visit_any_double(value)); } - Result visit_long_double(long double value) - { + Result visit_long_double(long double value) { return FMT_DISPATCH(visit_any_double(value)); } template - Result visit_any_double(T) - { + Result visit_any_double(T) { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_string(Arg::StringValue) - { + Result visit_string(Arg::StringValue) { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_wstring(Arg::StringValue) - { + Result visit_wstring(Arg::StringValue) { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_pointer(const void *) - { + Result visit_pointer(const void *) { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_custom(Arg::CustomValue) - { + Result visit_custom(Arg::CustomValue) { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit(const Arg &arg) - { - switch (arg.type) - { + Result visit(const Arg &arg) { + switch (arg.type) { default: assert(false); - // Fall through. + return Result(); case Arg::INT: return FMT_DISPATCH(visit_int(arg.int_value)); case Arg::UINT: @@ -1071,8 +1043,7 @@ public: return FMT_DISPATCH(visit_long_double(arg.long_double_value)); case Arg::CHAR: return FMT_DISPATCH(visit_char(arg.int_value)); - case Arg::CSTRING: - { + case Arg::CSTRING: { Value::StringValue str = arg.string; str.size = 0; return FMT_DISPATCH(visit_string(str)); @@ -1089,8 +1060,7 @@ public: } }; -class RuntimeError : public std::runtime_error -{ +class RuntimeError : public std::runtime_error { protected: RuntimeError() : std::runtime_error("") {} }; @@ -1102,8 +1072,7 @@ class ArgFormatter; /** An argument list. */ -class ArgList -{ +class ArgList { private: uint64_t types_; const internal::Value *values_; @@ -1119,12 +1088,10 @@ public: /** Returns the argument at specified index. */ - internal::Arg operator[](unsigned index) const - { + internal::Arg operator[](unsigned index) const { using internal::Arg; Arg arg; - if (index >= MAX_ARGS) - { + if (index >= MAX_ARGS) { arg.type = Arg::NONE; return arg; } @@ -1133,8 +1100,7 @@ public: Arg::Type type = static_cast((types_ & (mask << shift)) >> shift); arg.type = type; - if (type != Arg::NONE) - { + if (type != Arg::NONE) { internal::Value &value = arg; value = values_[index]; } @@ -1144,11 +1110,9 @@ public: struct FormatSpec; -namespace internal -{ +namespace internal { -class FormatterBase -{ +class FormatterBase { private: ArgList args_; int next_arg_index_; @@ -1157,8 +1121,7 @@ private: Arg do_get_arg(unsigned arg_index, const char *&error); protected: - void set_args(const ArgList &args) - { + void set_args(const ArgList &args) { args_ = args; next_arg_index_ = 0; } @@ -1171,8 +1134,7 @@ protected: Arg get_arg(unsigned arg_index, const char *&error); template - void write(BasicWriter &w, const Char *start, const Char *end) - { + void write(BasicWriter &w, const Char *start, const Char *end) { if (start != end) w << BasicStringRef(start, end - start); } @@ -1180,8 +1142,7 @@ protected: // A printf formatter. template -class PrintfFormatter : private FormatterBase -{ +class PrintfFormatter : private FormatterBase { private: void parse_flags(FormatSpec &spec, const Char *&s); @@ -1195,26 +1156,26 @@ private: public: void format(BasicWriter &writer, - BasicStringRef format, const ArgList &args); + BasicStringRef format_str, const ArgList &args); }; } // namespace internal // A formatter. template -class BasicFormatter : private internal::FormatterBase -{ +class BasicFormatter : private internal::FormatterBase { private: BasicWriter &writer_; const Char *start_; + FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter); + // Parses argument index and returns corresponding argument. internal::Arg parse_arg_index(const Char *&s); public: explicit BasicFormatter(BasicWriter &w) : writer_(w) {} - BasicWriter &writer() - { + BasicWriter &writer() { return writer_; } @@ -1223,14 +1184,12 @@ public: const Char *format(const Char *&format_str, const internal::Arg &arg); }; -enum Alignment -{ +enum Alignment { ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC }; // Flags. -enum -{ +enum { SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8, CHAR_FLAG = 0x10 // Argument has char type - used in error reporting. }; @@ -1240,37 +1199,29 @@ struct EmptySpec {}; // A type specifier. template -struct TypeSpec : EmptySpec -{ - Alignment align() const - { +struct TypeSpec : EmptySpec { + Alignment align() const { return ALIGN_DEFAULT; } - unsigned width() const - { + unsigned width() const { return 0; } - int precision() const - { + int precision() const { return -1; } - bool flag(unsigned) const - { + bool flag(unsigned) const { return false; } - char type() const - { + char type() const { return TYPE; } - char fill() const - { + char fill() const { return ' '; } }; // A width specifier. -struct WidthSpec -{ +struct WidthSpec { unsigned width_; // Fill is always wchar_t and cast to char if necessary to avoid having // two specialization of WidthSpec and its subclasses. @@ -1278,54 +1229,45 @@ struct WidthSpec WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {} - unsigned width() const - { + unsigned width() const { return width_; } - wchar_t fill() const - { + wchar_t fill() const { return fill_; } }; // An alignment specifier. -struct AlignSpec : WidthSpec -{ +struct AlignSpec : WidthSpec { Alignment align_; AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT) : WidthSpec(width, fill), align_(align) {} - Alignment align() const - { + Alignment align() const { return align_; } - int precision() const - { + int precision() const { return -1; } }; // An alignment and type specifier. template -struct AlignTypeSpec : AlignSpec -{ +struct AlignTypeSpec : AlignSpec { AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {} - bool flag(unsigned) const - { + bool flag(unsigned) const { return false; } - char type() const - { + char type() const { return TYPE; } }; // A full format specifier. -struct FormatSpec : AlignSpec -{ +struct FormatSpec : AlignSpec { unsigned flags_; int precision_; char type_; @@ -1334,41 +1276,35 @@ struct FormatSpec : AlignSpec unsigned width = 0, char type = 0, wchar_t fill = ' ') : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {} - bool flag(unsigned f) const - { + bool flag(unsigned f) const { return (flags_ & f) != 0; } - int precision() const - { + int precision() const { return precision_; } - char type() const - { + char type() const { return type_; } }; // An integer format specifier. template , typename Char = char> -class IntFormatSpec : public SpecT -{ +class IntFormatSpec : public SpecT { private: T value_; public: - IntFormatSpec(T value, const SpecT &spec = SpecT()) - : SpecT(spec), value_(value) {} + IntFormatSpec(T val, const SpecT &spec = SpecT()) + : SpecT(spec), value_(val) {} - T value() const - { + T value() const { return value_; } }; // A string format specifier. template -class StrFormatSpec : public AlignSpec -{ +class StrFormatSpec : public AlignSpec { private: const T *str_; @@ -1376,8 +1312,7 @@ public: StrFormatSpec(const T *str, unsigned width, wchar_t fill) : AlignSpec(width, fill), str_(str) {} - const T *str() const - { + const T *str() const { return str_; } }; @@ -1492,14 +1427,12 @@ std::string s = str(MemoryWriter() << pad("abc", 8)); */ template inline StrFormatSpec pad( - const Char *str, unsigned width, Char fill = ' ') -{ + const Char *str, unsigned width, Char fill = ' ') { return StrFormatSpec(str, width, fill); } inline StrFormatSpec pad( - const wchar_t *str, unsigned width, char fill = ' ') -{ + const wchar_t *str, unsigned width, char fill = ' ') { return StrFormatSpec(str, width, fill); } @@ -1522,29 +1455,24 @@ inline StrFormatSpec pad( # define FMT_GEN14(f) FMT_GEN13(f), f(13) # define FMT_GEN15(f) FMT_GEN14(f), f(14) -namespace internal -{ -inline uint64_t make_type() -{ +namespace internal { +inline uint64_t make_type() { return 0; } template -inline uint64_t make_type(const T &arg) -{ +inline uint64_t make_type(const T &arg) { return MakeValue::type(arg); } #if FMT_USE_VARIADIC_TEMPLATES template -inline uint64_t make_type(const Arg &first, const Args & ... tail) -{ +inline uint64_t make_type(const Arg &first, const Args & ... tail) { return make_type(first) | (make_type(tail...) << 4); } #else -struct ArgType -{ +struct ArgType { uint64_t type; ArgType() : type(0) {} @@ -1555,8 +1483,7 @@ struct ArgType # define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType() -inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) -{ +inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) | (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) | (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) | @@ -1612,6 +1539,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) // Emulates a variadic function returning void on a pre-C++11 compiler. # define FMT_VARIADIC_VOID(func, arg_type) \ + inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \ FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \ FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \ FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \ @@ -1666,10 +1594,9 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) An error returned by an operating system or a language runtime, for example a file opening error. */ -class SystemError : public internal::RuntimeError -{ +class SystemError : public internal::RuntimeError { private: - void init(int error_code, StringRef format_str, ArgList args); + void init(int err_code, StringRef format_str, ArgList args); protected: int error_code_; @@ -1681,21 +1608,35 @@ protected: public: /** \rst - Constructs a :cpp:class:`fmt::SystemError` object with the description - of the form "**: **", where ** is the - formatted message and ** is the system message corresponding - to the error code. + Constructs a :class:`fmt::SystemError` object with the description + of the form + + .. parsed-literal:: + **: ** + + where ** is the formatted message and ** is + the system message corresponding to the error code. *error_code* is a system error code as given by ``errno``. + If *error_code* is not a valid error code such as -1, the system message + may look like "Unknown error -1" and is platform-dependent. + + **Example**:: + + // This throws a SystemError with the description + // cannot open file 'madeup': No such file or directory + // or similar (system message may vary). + const char *filename = "madeup"; + std::FILE *file = std::fopen(filename, "r"); + if (!file) + throw fmt::SystemError(errno, "cannot open file '{}'", filename); \endrst */ - SystemError(int error_code, StringRef message) - { + SystemError(int error_code, StringRef message) { init(error_code, message, ArgList()); } FMT_VARIADIC_CTOR(SystemError, init, int, StringRef) - int error_code() const - { + int error_code() const { return error_code_; } }; @@ -1704,7 +1645,7 @@ public: \rst This template provides operations for formatting and writing data into a character stream. The output is stored in a buffer provided by a subclass -such as :cpp:class:`fmt::BasicMemoryWriter`. +such as :class:`fmt::BasicMemoryWriter`. You can use one of the following typedefs for common character types: @@ -1719,8 +1660,7 @@ You can use one of the following typedefs for common character types: \endrst */ template -class BasicWriter -{ +class BasicWriter { private: // Output buffer. internal::Buffer &buffer_; @@ -1731,13 +1671,11 @@ private: #if _SECURE_SCL // Returns pointer value. - static Char *get(CharPtr p) - { + static Char *get(CharPtr p) { return p.base(); } #else - static Char *get(Char *p) - { + static Char *get(Char *p) { return p; } #endif @@ -1749,8 +1687,7 @@ private: // Grows the buffer by n characters and returns a pointer to the newly // allocated area. - CharPtr grow_buffer(std::size_t n) - { + CharPtr grow_buffer(std::size_t n) { std::size_t size = buffer_.size(); buffer_.resize(size + n); return internal::make_ptr(&buffer_[size], n); @@ -1758,8 +1695,7 @@ private: // Prepare a buffer for integer formatting. CharPtr prepare_int_buffer(unsigned num_digits, - const EmptySpec &, const char *prefix, unsigned prefix_size) - { + const EmptySpec &, const char *prefix, unsigned prefix_size) { unsigned size = prefix_size + num_digits; CharPtr p = grow_buffer(size); std::copy(prefix, prefix + prefix_size, p); @@ -1787,11 +1723,22 @@ private: void write_str( const internal::Arg::StringValue &str, const FormatSpec &spec); - // This method is private to disallow writing a wide string to a - // char stream and vice versa. If you want to print a wide string - // as a pointer as std::ostream does, cast it to const void*. + // This following methods are private to disallow writing wide characters + // and strings to a char stream. If you want to print a wide string as a + // pointer as std::ostream does, cast it to const void*. // Do not implement! - void operator<<(typename internal::CharTraits::UnsupportedStrType); + void operator<<(typename internal::WCharHelper::Unsupported); + void operator<<( + typename internal::WCharHelper::Unsupported); + + // Appends floating-point length specifier to the format string. + // The second argument is only used for overload resolution. + void append_float_length(Char *&format_ptr, long double) { + *format_ptr++ = 'L'; + } + + template + void append_float_length(Char *&, T) {} friend class internal::ArgFormatter; friend class internal::PrintfFormatter; @@ -1811,8 +1758,7 @@ public: /** Returns the total number of characters written. */ - std::size_t size() const - { + std::size_t size() const { return buffer_.size(); } @@ -1820,8 +1766,7 @@ public: Returns a pointer to the output buffer content. No terminating null character is appended. */ - const Char *data() const FMT_NOEXCEPT(true) - { + const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; } @@ -1829,8 +1774,7 @@ public: Returns a pointer to the output buffer content with terminating null character appended. */ - const Char *c_str() const - { + const Char *c_str() const { std::size_t size = buffer_.size(); buffer_.reserve(size + 1); buffer_[size] = '\0'; @@ -1840,8 +1784,7 @@ public: /** Returns the content of the output buffer as an `std::string`. */ - std::basic_string str() const - { + std::basic_string str() const { return std::basic_string(&buffer_[0], buffer_.size()); } @@ -1864,49 +1807,41 @@ public: Current point: (-3.140000, +3.140000) - The output can be accessed using :meth:`data`, :meth:`c_str` or :meth:`str` - methods. + The output can be accessed using :func:`data()`, :func:`c_str` or + :func:`str` methods. See also :ref:`syntax`. \endrst */ - void write(BasicStringRef format, ArgList args) - { + void write(BasicStringRef format, ArgList args) { BasicFormatter(*this).format(format, args); } FMT_VARIADIC_VOID(write, BasicStringRef) - BasicWriter &operator<<(int value) - { + BasicWriter &operator<<(int value) { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(unsigned value) - { + BasicWriter &operator<<(unsigned value) { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(long value) - { + BasicWriter &operator<<(long value) { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(unsigned long value) - { + BasicWriter &operator<<(unsigned long value) { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(LongLong value) - { + BasicWriter &operator<<(LongLong value) { return *this << IntFormatSpec(value); } /** Formats *value* and writes it to the stream. */ - BasicWriter &operator<<(ULongLong value) - { + BasicWriter &operator<<(ULongLong value) { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(double value) - { + BasicWriter &operator<<(double value) { write_double(value, FormatSpec()); return *this; } @@ -1915,8 +1850,7 @@ public: Formats *value* using the general format for floating-point numbers (``'g'``) and writes it to the stream. */ - BasicWriter &operator<<(long double value) - { + BasicWriter &operator<<(long double value) { write_double(value, FormatSpec()); return *this; } @@ -1924,77 +1858,64 @@ public: /** Writes a character to the stream. */ - BasicWriter &operator<<(char value) - { + BasicWriter &operator<<(char value) { buffer_.push_back(value); return *this; } - BasicWriter &operator<<(wchar_t value) - { - buffer_.push_back(internal::CharTraits::convert(value)); + BasicWriter &operator<<( + typename internal::WCharHelper::Supported value) { + buffer_.push_back(value); return *this; } /** Writes *value* to the stream. */ - BasicWriter &operator<<(fmt::BasicStringRef value) - { + BasicWriter &operator<<(fmt::BasicStringRef value) { const Char *str = value.c_str(); buffer_.append(str, str + value.size()); return *this; } template - BasicWriter &operator<<(IntFormatSpec spec) - { + BasicWriter &operator<<(IntFormatSpec spec) { internal::CharTraits::convert(FillChar()); write_int(spec.value(), spec); return *this; } template - BasicWriter &operator<<(const StrFormatSpec &spec) - { + BasicWriter &operator<<(const StrFormatSpec &spec) { const StrChar *s = spec.str(); // TODO: error if fill is not convertible to Char write_str(s, std::char_traits::length(s), spec); return *this; } - void clear() FMT_NOEXCEPT(true) - { - buffer_.clear(); - } + void clear() FMT_NOEXCEPT{ buffer_.clear(); } }; template template typename BasicWriter::CharPtr BasicWriter::write_str( - const StrChar *s, std::size_t size, const AlignSpec &spec) -{ + const StrChar *s, std::size_t size, const AlignSpec &spec) { CharPtr out = CharPtr(); - if (spec.width() > size) - { + if (spec.width() > size) { out = grow_buffer(spec.width()); Char fill = static_cast(spec.fill()); - if (spec.align() == ALIGN_RIGHT) - { + if (spec.align() == ALIGN_RIGHT) { std::fill_n(out, spec.width() - size, fill); out += spec.width() - size; } - else if (spec.align() == ALIGN_CENTER) - { + else if (spec.align() == ALIGN_CENTER) { out = fill_padding(out, spec.width(), size, fill); } - else - { + else { std::fill_n(out + size, spec.width() - size, fill); } } - else - { + else { out = grow_buffer(size); } std::copy(s, s + size, out); @@ -2005,8 +1926,7 @@ template typename BasicWriter::CharPtr BasicWriter::fill_padding( CharPtr buffer, unsigned total_size, - std::size_t content_size, wchar_t fill) -{ + std::size_t content_size, wchar_t fill) { std::size_t padding = total_size - content_size; std::size_t left_padding = padding / 2; Char fill_char = static_cast(fill); @@ -2022,13 +1942,11 @@ template typename BasicWriter::CharPtr BasicWriter::prepare_int_buffer( unsigned num_digits, const Spec &spec, - const char *prefix, unsigned prefix_size) -{ + const char *prefix, unsigned prefix_size) { unsigned width = spec.width(); Alignment align = spec.align(); Char fill = static_cast(spec.fill()); - if (spec.precision() > static_cast(num_digits)) - { + if (spec.precision() > static_cast(num_digits)) { // Octal prefix '0' is counted as a digit, so ignore it if precision // is specified. if (prefix_size > 0 && prefix[prefix_size - 1] == '0') @@ -2039,53 +1957,44 @@ BasicWriter::prepare_int_buffer( return prepare_int_buffer(num_digits, subspec, prefix, prefix_size); buffer_.reserve(width); unsigned fill_size = width - number_size; - if (align != ALIGN_LEFT) - { + if (align != ALIGN_LEFT) { CharPtr p = grow_buffer(fill_size); std::fill(p, p + fill_size, fill); } CharPtr result = prepare_int_buffer( num_digits, subspec, prefix, prefix_size); - if (align == ALIGN_LEFT) - { + if (align == ALIGN_LEFT) { CharPtr p = grow_buffer(fill_size); std::fill(p, p + fill_size, fill); } return result; } unsigned size = prefix_size + num_digits; - if (width <= size) - { + if (width <= size) { CharPtr p = grow_buffer(size); std::copy(prefix, prefix + prefix_size, p); return p + size - 1; } CharPtr p = grow_buffer(width); CharPtr end = p + width; - if (align == ALIGN_LEFT) - { + if (align == ALIGN_LEFT) { std::copy(prefix, prefix + prefix_size, p); p += size; std::fill(p, end, fill); } - else if (align == ALIGN_CENTER) - { + else if (align == ALIGN_CENTER) { p = fill_padding(p, width, size, fill); std::copy(prefix, prefix + prefix_size, p); p += size; } - else - { - if (align == ALIGN_NUMERIC) - { - if (prefix_size != 0) - { + else { + if (align == ALIGN_NUMERIC) { + if (prefix_size != 0) { p = std::copy(prefix, prefix + prefix_size, p); size -= prefix_size; } } - else - { + else { std::copy(prefix, prefix + prefix_size, end - size); } std::fill(p, end - size, fill); @@ -2096,28 +2005,23 @@ BasicWriter::prepare_int_buffer( template template -void BasicWriter::write_int(T value, Spec spec) -{ +void BasicWriter::write_int(T value, Spec spec) { unsigned prefix_size = 0; typedef typename internal::IntTraits::MainType UnsignedType; UnsignedType abs_value = value; char prefix[4] = ""; - if (internal::is_negative(value)) - { + if (internal::is_negative(value)) { prefix[0] = '-'; ++prefix_size; abs_value = 0 - abs_value; } - else if (spec.flag(SIGN_FLAG)) - { + else if (spec.flag(SIGN_FLAG)) { prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' '; ++prefix_size; } - switch (spec.type()) - { + switch (spec.type()) { case 0: - case 'd': - { + case 'd': { unsigned num_digits = internal::count_digits(abs_value); CharPtr p = prepare_int_buffer( num_digits, spec, prefix, prefix_size) + 1 - num_digits; @@ -2125,74 +2029,57 @@ void BasicWriter::write_int(T value, Spec spec) break; } case 'x': - case 'X': - { + case 'X': { UnsignedType n = abs_value; - if (spec.flag(HASH_FLAG)) - { + if (spec.flag(HASH_FLAG)) { prefix[prefix_size++] = '0'; prefix[prefix_size++] = spec.type(); } unsigned num_digits = 0; - do - { + do { ++num_digits; - } - while ((n >>= 4) != 0); + } while ((n >>= 4) != 0); Char *p = get(prepare_int_buffer( num_digits, spec, prefix, prefix_size)); n = abs_value; const char *digits = spec.type() == 'x' ? "0123456789abcdef" : "0123456789ABCDEF"; - do - { + do { *p-- = digits[n & 0xf]; - } - while ((n >>= 4) != 0); + } while ((n >>= 4) != 0); break; } case 'b': - case 'B': - { + case 'B': { UnsignedType n = abs_value; - if (spec.flag(HASH_FLAG)) - { + if (spec.flag(HASH_FLAG)) { prefix[prefix_size++] = '0'; prefix[prefix_size++] = spec.type(); } unsigned num_digits = 0; - do - { + do { ++num_digits; - } - while ((n >>= 1) != 0); + } while ((n >>= 1) != 0); Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); n = abs_value; - do - { + do { *p-- = '0' + (n & 1); - } - while ((n >>= 1) != 0); + } while ((n >>= 1) != 0); break; } - case 'o': - { + case 'o': { UnsignedType n = abs_value; if (spec.flag(HASH_FLAG)) prefix[prefix_size++] = '0'; unsigned num_digits = 0; - do - { + do { ++num_digits; - } - while ((n >>= 3) != 0); + } while ((n >>= 3) != 0); Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); n = abs_value; - do - { + do { *p-- = '0' + (n & 7); - } - while ((n >>= 3) != 0); + } while ((n >>= 3) != 0); break; } default: @@ -2205,13 +2092,11 @@ void BasicWriter::write_int(T value, Spec spec) template template void BasicWriter::write_double( - T value, const FormatSpec &spec) -{ + T value, const FormatSpec &spec) { // Check type. char type = spec.type(); bool upper = false; - switch (type) - { + switch (type) { case 0: type = 'g'; break; @@ -2225,7 +2110,7 @@ void BasicWriter::write_double( // MSVC's printf doesn't support 'F'. type = 'f'; #endif - // Fall through. + // Fall through. case 'E': case 'G': case 'A': @@ -2239,45 +2124,39 @@ void BasicWriter::write_double( char sign = 0; // Use getsign instead of value < 0 because the latter is always // false for NaN. - if (internal::getsign(static_cast(value))) - { + if (internal::getsign(static_cast(value))) { sign = '-'; value = -value; } - else if (spec.flag(SIGN_FLAG)) - { + else if (spec.flag(SIGN_FLAG)) { sign = spec.flag(PLUS_FLAG) ? '+' : ' '; } - if (value != value) - { + if (value != value) { // Format NaN ourselves because sprintf's output is not consistent // across platforms. - std::size_t size = 4; + std::size_t nan_size = 4; const char *nan = upper ? " NAN" : " nan"; - if (!sign) - { - --size; + if (!sign) { + --nan_size; ++nan; } - CharPtr out = write_str(nan, size, spec); + CharPtr out = write_str(nan, nan_size, spec); if (sign) *out = sign; return; } - if (internal::isinfinity(value)) - { + if (internal::isinfinity(value)) { // Format infinity ourselves because sprintf's output is not consistent // across platforms. - std::size_t size = 4; + std::size_t inf_size = 4; const char *inf = upper ? " INF" : " inf"; - if (!sign) - { - --size; + if (!sign) { + --inf_size; ++inf; } - CharPtr out = write_str(inf, size, spec); + CharPtr out = write_str(inf, inf_size, spec); if (sign) *out = sign; return; @@ -2285,8 +2164,7 @@ void BasicWriter::write_double( std::size_t offset = buffer_.size(); unsigned width = spec.width(); - if (sign) - { + if (sign) { buffer_.reserve(buffer_.size() + (std::max)(width, 1u)); if (width > 0) --width; @@ -2301,72 +2179,61 @@ void BasicWriter::write_double( unsigned width_for_sprintf = width; if (spec.flag(HASH_FLAG)) *format_ptr++ = '#'; - if (spec.align() == ALIGN_CENTER) - { + if (spec.align() == ALIGN_CENTER) { width_for_sprintf = 0; } - else - { + else { if (spec.align() == ALIGN_LEFT) *format_ptr++ = '-'; if (width != 0) *format_ptr++ = '*'; } - if (spec.precision() >= 0) - { + if (spec.precision() >= 0) { *format_ptr++ = '.'; *format_ptr++ = '*'; } - if (internal::IsLongDouble::VALUE) - *format_ptr++ = 'L'; + + append_float_length(format_ptr, value); *format_ptr++ = type; *format_ptr = '\0'; // Format using snprintf. Char fill = static_cast(spec.fill()); - for (;;) - { - std::size_t size = buffer_.capacity() - offset; + for (;;) { + std::size_t buffer_size = buffer_.capacity() - offset; #if _MSC_VER // MSVC's vsnprintf_s doesn't work with zero size, so reserve // space for at least one extra character to make the size non-zero. // Note that the buffer's capacity will increase by more than 1. - if (size == 0) - { + if (buffer_size == 0) { buffer_.reserve(offset + 1); - size = buffer_.capacity() - offset; + buffer_size = buffer_.capacity() - offset; } #endif Char *start = &buffer_[offset]; int n = internal::CharTraits::format_float( - start, size, format, width_for_sprintf, spec.precision(), value); - if (n >= 0 && offset + n < buffer_.capacity()) - { - if (sign) - { + start, buffer_size, format, width_for_sprintf, spec.precision(), value); + if (n >= 0 && offset + n < buffer_.capacity()) { + if (sign) { if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) || - *start != ' ') - { + *start != ' ') { *(start - 1) = sign; sign = 0; } - else - { + else { *(start - 1) = fill; } ++n; } if (spec.align() == ALIGN_CENTER && - spec.width() > static_cast(n)) - { - unsigned width = spec.width(); + spec.width() > static_cast(n)) { + width = spec.width(); CharPtr p = grow_buffer(width); std::copy(p, p + n, p + (width - n) / 2); fill_padding(p, spec.width(), n, fill); return; } - if (spec.fill() != ' ' || sign) - { + if (spec.fill() != ' ' || sign) { while (*start == ' ') *start++ = fill; if (sign) @@ -2416,8 +2283,7 @@ accessed as a C string with ``out.c_str()``. \endrst */ template > -class BasicMemoryWriter : public BasicWriter -{ +class BasicMemoryWriter : public BasicWriter { private: internal::MemoryBuffer buffer_; @@ -2427,19 +2293,17 @@ public: #if FMT_USE_RVALUE_REFERENCES /** - Constructs a ``BasicMemoryWriter`` object moving the content of the other - object to it. + Constructs a :class:`fmt::BasicMemoryWriter` object moving the content + of the other object to it. */ BasicMemoryWriter(BasicMemoryWriter &&other) - : BasicWriter(buffer_), buffer_(std::move(other.buffer_)) - { + : BasicWriter(buffer_), buffer_(std::move(other.buffer_)) { } /** Moves the content of the other ``BasicMemoryWriter`` object to this one. */ - BasicMemoryWriter &operator=(BasicMemoryWriter &&other) - { + BasicMemoryWriter &operator=(BasicMemoryWriter &&other) { buffer_ = std::move(other.buffer_); return *this; } @@ -2451,44 +2315,59 @@ typedef BasicMemoryWriter WMemoryWriter; // Formats a value. template -void format(BasicFormatter &f, const Char *&format_str, const T &value) -{ +void format(BasicFormatter &f, const Char *&format_str, const T &value) { std::basic_ostringstream os; os << value; internal::Arg arg; internal::Value &arg_value = arg; std::basic_string str = os.str(); arg_value = internal::MakeValue(str); - arg.type = internal::Arg::STRING; + arg.type = static_cast( + internal::MakeValue::type(str)); format_str = f.format(format_str, arg); } // Reports a system error without throwing an exception. // Can be used to report errors from destructors. -void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT(true); +void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT; #ifdef _WIN32 -/** -A Windows error. -*/ -class WindowsError : public SystemError -{ +/** A Windows error. */ +class WindowsError : public SystemError { private: void init(int error_code, StringRef format_str, ArgList args); public: /** \rst - Constructs a :cpp:class:`fmt::WindowsError` object with the description - of the form "**: **", where ** is the - formatted message and ** is the system message corresponding - to the error code. + Constructs a :class:`fmt::WindowsError` object with the description + of the form + + .. parsed-literal:: + **: ** + + where ** is the formatted message and ** is the + system message corresponding to the error code. *error_code* is a Windows error code as given by ``GetLastError``. + If *error_code* is not a valid error code such as -1, the system message + will look like "error -1". + + **Example**:: + + // This throws a WindowsError with the description + // cannot open file 'madeup': The system cannot find the file specified. + // or similar (system message may vary). + const char *filename = "madeup"; + LPOFSTRUCT of = LPOFSTRUCT(); + HFILE file = OpenFile(filename, &of, OF_READ); + if (file == HFILE_ERROR) { + throw fmt::WindowsError(GetLastError(), + "cannot open file '{}'", filename); + } \endrst */ - WindowsError(int error_code, StringRef message) - { + WindowsError(int error_code, StringRef message) { init(error_code, message, ArgList()); } FMT_VARIADIC_CTOR(WindowsError, init, int, StringRef) @@ -2496,7 +2375,7 @@ public: // Reports a Windows error without throwing an exception. // Can be used to report errors from destructors. -void report_windows_error(int error_code, StringRef message) FMT_NOEXCEPT(true); +void report_windows_error(int error_code, StringRef message) FMT_NOEXCEPT; #endif @@ -2519,15 +2398,13 @@ Formats arguments and returns the result as a string. std::string message = format("The answer is {}", 42); \endrst */ -inline std::string format(StringRef format_str, ArgList args) -{ +inline std::string format(StringRef format_str, ArgList args) { MemoryWriter w; w.write(format_str, args); return w.str(); } -inline std::wstring format(WStringRef format_str, ArgList args) -{ +inline std::wstring format(WStringRef format_str, ArgList args) { WMemoryWriter w; w.write(format_str, args); return w.str(); @@ -2567,8 +2444,7 @@ print(cerr, "Don't {}!", "panic"); void print(std::ostream &os, StringRef format_str, ArgList args); template -void printf(BasicWriter &w, BasicStringRef format, ArgList args) -{ +void printf(BasicWriter &w, BasicStringRef format, ArgList args) { internal::PrintfFormatter().format(w, format, args); } @@ -2581,8 +2457,7 @@ Formats arguments and returns the result as a string. std::string message = fmt::sprintf("The answer is %d", 42); \endrst */ -inline std::string sprintf(StringRef format, ArgList args) -{ +inline std::string sprintf(StringRef format, ArgList args) { MemoryWriter w; printf(w, format, args); return w.str(); @@ -2608,16 +2483,14 @@ Prints formatted data to ``stdout``. fmt::printf("Elapsed time: %.2f seconds", 1.23); \endrst */ -inline int printf(StringRef format, ArgList args) -{ +inline int printf(StringRef format, ArgList args) { return fprintf(stdout, format, args); } /** Fast integer formatter. */ -class FormatInt -{ +class FormatInt { private: // Buffer should be large enough to hold all digits (digits10 + 1), // a sign and a null character. @@ -2626,11 +2499,9 @@ private: char *str_; // Formats value in reverse and returns the number of digits. - char *format_decimal(ULongLong value) - { + char *format_decimal(ULongLong value) { char *buffer_end = buffer_ + BUFFER_SIZE - 1; - while (value >= 100) - { + while (value >= 100) { // Integer division is slow so do it for a group of two digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. @@ -2639,8 +2510,7 @@ private: *--buffer_end = internal::Data::DIGITS[index + 1]; *--buffer_end = internal::Data::DIGITS[index]; } - if (value < 10) - { + if (value < 10) { *--buffer_end = static_cast('0' + value); return buffer_end; } @@ -2650,8 +2520,7 @@ private: return buffer_end; } - void FormatSigned(LongLong value) - { + void FormatSigned(LongLong value) { ULongLong abs_value = static_cast(value); bool negative = value < 0; if (negative) @@ -2662,16 +2531,13 @@ private: } public: - explicit FormatInt(int value) - { + explicit FormatInt(int value) { FormatSigned(value); } - explicit FormatInt(long value) - { + explicit FormatInt(long value) { FormatSigned(value); } - explicit FormatInt(LongLong value) - { + explicit FormatInt(LongLong value) { FormatSigned(value); } explicit FormatInt(unsigned value) : str_(format_decimal(value)) {} @@ -2681,8 +2547,7 @@ public: /** Returns the number of characters written to the output buffer. */ - std::size_t size() const - { + std::size_t size() const { return buffer_ - str_ + BUFFER_SIZE - 1; } @@ -2690,8 +2555,7 @@ public: Returns a pointer to the output buffer content. No terminating null character is appended. */ - const char *data() const - { + const char *data() const { return str_; } @@ -2699,8 +2563,7 @@ public: Returns a pointer to the output buffer content with terminating null character appended. */ - const char *c_str() const - { + const char *c_str() const { buffer_[BUFFER_SIZE - 1] = '\0'; return str_; } @@ -2708,8 +2571,7 @@ public: /** Returns the content of the output buffer as an `std::string`. */ - std::string str() const - { + std::string str() const { return std::string(str_, size()); } }; @@ -2718,18 +2580,14 @@ public: // a pointer to the end of the formatted string. This function doesn't // write a terminating null character. template -inline void format_decimal(char *&buffer, T value) -{ +inline void format_decimal(char *&buffer, T value) { typename internal::IntTraits::MainType abs_value = value; - if (internal::is_negative(value)) - { + if (internal::is_negative(value)) { *buffer++ = '-'; abs_value = 0 - abs_value; } - if (abs_value < 100) - { - if (abs_value < 10) - { + if (abs_value < 100) { + if (abs_value < 10) { *buffer++ = static_cast('0' + abs_value); return; } @@ -2742,9 +2600,7 @@ inline void format_decimal(char *&buffer, T value) internal::format_decimal(buffer, abs_value, num_digits); buffer += num_digits; } -} // ns fmt -} // ns deatils -} // ns spdlog +} #if FMT_GCC_VERSION // Use the system_header pragma to suppress warnings about variadic macros @@ -2851,12 +2707,7 @@ fmt::print(format, args...); #define FMT_VARIADIC_W(ReturnType, func, ...) \ FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__) -namespace spdlog -{ -namespace details -{ -namespace fmt -{ +namespace fmt { FMT_VARIADIC(std::string, format, StringRef) FMT_VARIADIC_W(std::wstring, format, WStringRef) FMT_VARIADIC(void, print, StringRef) @@ -2867,20 +2718,17 @@ FMT_VARIADIC(std::string, sprintf, StringRef) FMT_VARIADIC(int, printf, StringRef) FMT_VARIADIC(int, fprintf, std::FILE *, StringRef) } -} -} // Restore warnings. #if FMT_GCC_VERSION >= 406 # pragma GCC diagnostic pop #endif - -#define FMT_HEADER_ONLY +#ifdef __clang__ +# pragma clang diagnostic pop +#endif +#ifdef FMT_HEADER_ONLY # include "format.cc" - -#ifdef __GNUC__ -# pragma GCC diagnostic pop //pop -Wshadow warnings ignore #endif -#endif // SPDLOG_FMT_FORMAT_H_ +#endif // FMT_FORMAT_H_ \ No newline at end of file diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index e231b4d8..f31b918e 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -478,7 +478,7 @@ inline void spdlog::pattern_formatter::handle_flag(char flag) { switch (flag) { - // logger name + // logger name case 'n': _formatters.push_back(std::unique_ptr(new details::name_formatter())); break; @@ -610,8 +610,8 @@ inline void spdlog::pattern_formatter::format(details::log_msg& msg) //write eol msg.formatted << details::os::eol(); } - catch(const details::fmt::FormatError& e) + catch(const fmt::FormatError& e) { - throw spdlog_ex(details::fmt::format("formatting error while processing format string: {}", e.what())); + throw spdlog_ex(fmt::format("formatting error while processing format string: {}", e.what())); } } diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index dd463d54..ab6a0d08 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -99,7 +99,7 @@ protected: private: static std::string calc_filename(const std::string& filename, std::size_t index, const std::string& extension) { - details::fmt::MemoryWriter w; + fmt::MemoryWriter w; if (index) w.write("{}.{}.{}", filename, index, extension); else @@ -207,7 +207,7 @@ private: static std::string calc_filename(const std::string& basename, const std::string& extension) { std::tm tm = spdlog::details::os::localtime(); - details::fmt::MemoryWriter w; + fmt::MemoryWriter w; w.write("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}.{}", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, extension); return w.str(); } From 31a011e67cd00d1ecb3a5fcbea934ca14fa873ce Mon Sep 17 00:00:00 2001 From: gabime Date: Thu, 12 Mar 2015 00:49:28 +0200 Subject: [PATCH 13/60] Fixed daily sink syntax error and redundant file close --- include/spdlog/sinks/file_sinks.h | 28 +++++++++------------------- 1 file changed, 9 insertions(+), 19 deletions(-) diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index ab6a0d08..9ec8f46b 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -30,21 +30,19 @@ #include "../details/file_helper.h" #include "../details/format.h" - namespace spdlog { namespace sinks { - /* * Trivial file sink with single file as target */ template -class simple_file_sink : public base_sink +class simple_file_sink : public base_sink < Mutex > { public: explicit simple_file_sink(const std::string &filename, - bool force_flush=false): + bool force_flush = false) : _file_helper(force_flush) { _file_helper.open(filename); @@ -64,14 +62,14 @@ typedef simple_file_sink simple_file_sink_st; /* * Rotating file sink based on size -*/ + */ template -class rotating_file_sink : public base_sink +class rotating_file_sink : public base_sink < Mutex > { public: rotating_file_sink(const std::string &base_filename, const std::string &extension, std::size_t max_size, std::size_t max_files, - bool force_flush=false): + bool force_flush = false) : _base_filename(base_filename), _extension(extension), _max_size(max_size), @@ -82,12 +80,11 @@ public: _file_helper.open(calc_filename(_base_filename, 0, _extension)); } - protected: void _sink_it(const details::log_msg& msg) override { _current_size += msg.formatted.size(); - if (_current_size > _max_size) + if (_current_size > _max_size) { _rotate(); _current_size = msg.formatted.size(); @@ -95,7 +92,6 @@ protected: _file_helper.write(msg); } - private: static std::string calc_filename(const std::string& filename, std::size_t index, const std::string& extension) { @@ -107,14 +103,12 @@ private: return w.str(); } - // Rotate files: // log.txt -> log.1.txt // log.1.txt -> log2.txt // log.2.txt -> log3.txt // log.3.txt -> delete - void _rotate() { _file_helper.close(); @@ -152,7 +146,7 @@ typedef rotating_file_sinkrotating_file_sink_st; * Rotating file sink based on date. rotates at midnight */ template -class daily_file_sink:public base_sink +class daily_file_sink :public base_sink < Mutex > { public: //create daily file sink which rotates on given time @@ -161,7 +155,7 @@ public: const std::string& extension, int rotation_hour, int rotation_minute, - bool force_flush=false): _base_filename(base_filename), + bool force_flush = false) : _base_filename(base_filename), _extension(extension), _rotation_h(rotation_hour), _rotation_m(rotation_minute), @@ -169,17 +163,15 @@ public: { if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59) throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor"); - _rotation_tp = _next_rotation_tp(), + _rotation_tp = _next_rotation_tp(); _file_helper.open(calc_filename(_base_filename, _extension)); } - protected: void _sink_it(const details::log_msg& msg) override { if (std::chrono::system_clock::now() >= _rotation_tp) { - _file_helper.close(); _file_helper.open(calc_filename(_base_filename, _extension)); _rotation_tp = _next_rotation_tp(); } @@ -218,8 +210,6 @@ private: int _rotation_m; std::chrono::system_clock::time_point _rotation_tp; details::file_helper _file_helper; - - }; typedef daily_file_sink daily_file_sink_mt; From e301d94afa4c84e16d8c0da679f44770dd135551 Mon Sep 17 00:00:00 2001 From: Ivan Shynkarenka Date: Thu, 12 Mar 2015 22:31:37 +0300 Subject: [PATCH 14/60] Add async queue size as a separate parameter from sample size --- example/bench.cpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/example/bench.cpp b/example/bench.cpp index b2f41b12..e82e7ade 100644 --- a/example/bench.cpp +++ b/example/bench.cpp @@ -50,7 +50,8 @@ void bench_mt(int howmany, std::shared_ptr log, int thread_count int main(int argc, char* argv[]) { - int howmany = 1048576; + int queue_size = 65536; + int howmany = 1000000; int threads = 10; bool auto_flush = false; int file_size = 30 * 1024 * 1024; @@ -63,6 +64,8 @@ int main(int argc, char* argv[]) howmany = atoi(argv[1]); if (argc > 2) threads = atoi(argv[2]); + if (argc > 3) + queue_size = atoi(argv[3]); cout << "*******************************************************************************\n"; @@ -92,7 +95,7 @@ int main(int argc, char* argv[]) cout << "*******************************************************************************\n"; - spdlog::set_async_mode(howmany); + spdlog::set_async_mode(queue_size); for(int i = 0; i < 3; ++i) { From 385016496bdc9aa2b20384e78427513d2135925f Mon Sep 17 00:00:00 2001 From: Ivan Shynkarenka Date: Thu, 12 Mar 2015 22:31:37 +0300 Subject: [PATCH 15/60] Add async queue size as a separate parameter from sample size --- example/bench.cpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/example/bench.cpp b/example/bench.cpp index b2f41b12..ba76e2a6 100644 --- a/example/bench.cpp +++ b/example/bench.cpp @@ -50,7 +50,8 @@ void bench_mt(int howmany, std::shared_ptr log, int thread_count int main(int argc, char* argv[]) { - int howmany = 1048576; + int queue_size = 1048576; + int howmany = 1000000; int threads = 10; bool auto_flush = false; int file_size = 30 * 1024 * 1024; @@ -63,6 +64,8 @@ int main(int argc, char* argv[]) howmany = atoi(argv[1]); if (argc > 2) threads = atoi(argv[2]); + if (argc > 3) + queue_size = atoi(argv[3]); cout << "*******************************************************************************\n"; @@ -92,7 +95,7 @@ int main(int argc, char* argv[]) cout << "*******************************************************************************\n"; - spdlog::set_async_mode(howmany); + spdlog::set_async_mode(queue_size); for(int i = 0; i < 3; ++i) { From 3556c87a51bc89696f6230b4c6c76f88c18d5990 Mon Sep 17 00:00:00 2001 From: gabime Date: Wed, 18 Mar 2015 23:31:17 +0200 Subject: [PATCH 16/60] Fixed issue #61 (spdlog::set_level(...) does not affect loggers created afterwords) --- include/spdlog/details/registry.h | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index 2d1c2339..7a283ecd 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -41,7 +41,6 @@ namespace spdlog { namespace details { - class registry { public: @@ -94,7 +93,6 @@ public: return create(logger_name, { sink }); } - void formatter(formatter_ptr f) { std::lock_guard lock(_mutex); @@ -103,14 +101,12 @@ public: l.second->set_formatter(_formatter); } - void set_pattern(const std::string& pattern) { std::lock_guard lock(_mutex); _formatter = std::make_shared(pattern); for (auto& l : _loggers) l.second->set_formatter(_formatter); - } void set_level(level::level_enum log_level) @@ -118,6 +114,7 @@ public: std::lock_guard lock(_mutex); for (auto& l : _loggers) l.second->set_level(log_level); + _level = log_level; } void set_async_mode(size_t q_size, const async_overflow_policy overflow_policy, const std::function& worker_warmup_cb) @@ -135,7 +132,6 @@ public: _async_mode = false; } - static registry& instance() { static registry s_instance; From 6fe03c778066b98193fdcf90bb7a5e34438692bc Mon Sep 17 00:00:00 2001 From: gabime Date: Sat, 21 Mar 2015 13:29:53 +0200 Subject: [PATCH 17/60] Fix issue #64 (clang build fails due to `details/format.h` diagnostic pop without prior push) --- include/spdlog/details/format.h | 56 ++++++++++++++++----------------- 1 file changed, 27 insertions(+), 29 deletions(-) diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h index 334e8746..3f953024 100644 --- a/include/spdlog/details/format.h +++ b/include/spdlog/details/format.h @@ -102,6 +102,7 @@ inline uint32_t clzll(uint64_t x) { #endif #ifdef __clang__ +# pragma clang diagnostic push # pragma clang diagnostic ignored "-Wdocumentation" #endif @@ -174,7 +175,6 @@ inline uint32_t clzll(uint64_t x) { #endif namespace fmt { - // Fix the warning about long long on older versions of GCC // that don't support the diagnostic pragma. FMT_GCC_EXTENSION typedef long long LongLong; @@ -288,7 +288,6 @@ public: }; namespace internal { - // The number of characters to store in the MemoryBuffer object itself // to avoid dynamic memory allocation. enum { INLINE_BUFFER_SIZE = 500 }; @@ -379,7 +378,7 @@ void Buffer::append(const T *begin, const T *end) { // A memory buffer for POD types with the first SIZE elements stored in // the object itself. template > -class MemoryBuffer : private Allocator, public Buffer { +class MemoryBuffer : private Allocator, public Buffer < T > { private: T data_[SIZE]; @@ -516,7 +515,7 @@ template class CharTraits; template <> -class CharTraits : public BasicCharTraits { +class CharTraits : public BasicCharTraits < char > { private: // Conversion from wchar_t to char is not allowed. static char convert(wchar_t); @@ -533,7 +532,7 @@ public: }; template <> -class CharTraits : public BasicCharTraits { +class CharTraits : public BasicCharTraits < wchar_t > { public: static wchar_t convert(char value) { return value; @@ -557,7 +556,7 @@ struct SignChecker { }; template <> -struct SignChecker { +struct SignChecker < false > { template static bool is_negative(T) { return false; @@ -578,7 +577,7 @@ struct TypeSelector { }; template <> -struct TypeSelector { +struct TypeSelector < false > { typedef uint64_t Type; }; @@ -754,7 +753,7 @@ struct NonZero { }; template <> -struct NonZero<0> { +struct NonZero < 0 > { enum { VALUE = 1 }; }; @@ -815,7 +814,7 @@ struct WCharHelper { }; template -struct WCharHelper { +struct WCharHelper < T, wchar_t > { typedef T Supported; typedef None Unsupported; }; @@ -929,7 +928,7 @@ public: #define FMT_MAKE_WSTR_VALUE(Type, TYPE) \ MakeValue(typename WCharHelper::Supported value) { \ set_string(value); \ - } \ + } \ static uint64_t type(Type) { return Arg::TYPE; } FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING) @@ -943,7 +942,7 @@ public: template MakeValue(const T &value) { custom.value = &value; - custom.format = &format_custom_arg; + custom.format = &format_custom_arg < T > ; } template static uint64_t type(const T &) { @@ -1111,7 +1110,6 @@ public: struct FormatSpec; namespace internal { - class FormatterBase { private: ArgList args_; @@ -1360,26 +1358,26 @@ IntFormatSpec, Char> pad( #define FMT_DEFINE_INT_FORMATTERS(TYPE) \ inline IntFormatSpec > bin(TYPE value) { \ return IntFormatSpec >(value, TypeSpec<'b'>()); \ - } \ + } \ \ inline IntFormatSpec > oct(TYPE value) { \ return IntFormatSpec >(value, TypeSpec<'o'>()); \ - } \ + } \ \ inline IntFormatSpec > hex(TYPE value) { \ return IntFormatSpec >(value, TypeSpec<'x'>()); \ - } \ + } \ \ inline IntFormatSpec > hexu(TYPE value) { \ return IntFormatSpec >(value, TypeSpec<'X'>()); \ - } \ + } \ \ template \ inline IntFormatSpec > pad( \ IntFormatSpec > f, unsigned width) { \ return IntFormatSpec >( \ f.value(), AlignTypeSpec(width, ' ')); \ - } \ + } \ \ /* For compatibility with older compilers we provide two overloads for pad, */ \ /* one that takes a fill character and one that doesn't. In the future this */ \ @@ -1391,20 +1389,20 @@ inline IntFormatSpec, Char> pad( \ unsigned width, Char fill) { \ return IntFormatSpec, Char>( \ f.value(), AlignTypeSpec(width, fill)); \ - } \ + } \ \ inline IntFormatSpec > pad( \ TYPE value, unsigned width) { \ return IntFormatSpec >( \ value, AlignTypeSpec<0>(width, ' ')); \ - } \ + } \ \ template \ inline IntFormatSpec, Char> pad( \ TYPE value, unsigned width, Char fill) { \ return IntFormatSpec, Char>( \ value, AlignTypeSpec<0>(width, fill)); \ - } + } FMT_DEFINE_INT_FORMATTERS(int) FMT_DEFINE_INT_FORMATTERS(long) @@ -1506,9 +1504,9 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { const fmt::internal::Value values[ \ fmt::internal::NonZero::VALUE] = { \ fmt::internal::MakeValue(args)... \ - }; \ + }; \ func(arg1, ArgList(fmt::internal::make_type(args...), values)); \ - } + } // Defines a variadic constructor. # define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ @@ -1518,9 +1516,9 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { const fmt::internal::Value values[ \ fmt::internal::NonZero::VALUE] = { \ MakeValue(args)... \ - }; \ + }; \ func(arg0, arg1, ArgList(fmt::internal::make_type(args...), values)); \ - } + } #else @@ -1535,7 +1533,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { const fmt::internal::Value vals[] = {FMT_GEN(n, FMT_MAKE_REF)}; \ func(arg1, fmt::ArgList( \ fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), vals)); \ - } + } // Emulates a variadic function returning void on a pre-C++11 compiler. # define FMT_VARIADIC_VOID(func, arg_type) \ @@ -1552,7 +1550,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { const fmt::internal::Value vals[] = {FMT_GEN(n, FMT_MAKE_REF)}; \ func(arg0, arg1, fmt::ArgList( \ fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), vals)); \ - } + } // Emulates a variadic constructor on a pre-C++11 compiler. # define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ @@ -1740,8 +1738,8 @@ private: template void append_float_length(Char *&, T) {} - friend class internal::ArgFormatter; - friend class internal::PrintfFormatter; + friend class internal::ArgFormatter < Char > ; + friend class internal::PrintfFormatter < Char > ; protected: /** @@ -2283,7 +2281,7 @@ accessed as a C string with ``out.c_str()``. \endrst */ template > -class BasicMemoryWriter : public BasicWriter { +class BasicMemoryWriter : public BasicWriter < Char > { private: internal::MemoryBuffer buffer_; From a24ff547605b9168da3763844831b45f8ff0fde7 Mon Sep 17 00:00:00 2001 From: gabime Date: Sat, 21 Mar 2015 13:42:59 +0200 Subject: [PATCH 18/60] Fixed source formatting --- include/spdlog/details/format.h | 55 +++++++++++++++++---------------- 1 file changed, 29 insertions(+), 26 deletions(-) diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h index 3f953024..9de22521 100644 --- a/include/spdlog/details/format.h +++ b/include/spdlog/details/format.h @@ -175,6 +175,7 @@ inline uint32_t clzll(uint64_t x) { #endif namespace fmt { + // Fix the warning about long long on older versions of GCC // that don't support the diagnostic pragma. FMT_GCC_EXTENSION typedef long long LongLong; @@ -288,6 +289,7 @@ public: }; namespace internal { + // The number of characters to store in the MemoryBuffer object itself // to avoid dynamic memory allocation. enum { INLINE_BUFFER_SIZE = 500 }; @@ -378,7 +380,7 @@ void Buffer::append(const T *begin, const T *end) { // A memory buffer for POD types with the first SIZE elements stored in // the object itself. template > -class MemoryBuffer : private Allocator, public Buffer < T > { +class MemoryBuffer : private Allocator, public Buffer { private: T data_[SIZE]; @@ -515,7 +517,7 @@ template class CharTraits; template <> -class CharTraits : public BasicCharTraits < char > { +class CharTraits : public BasicCharTraits { private: // Conversion from wchar_t to char is not allowed. static char convert(wchar_t); @@ -532,7 +534,7 @@ public: }; template <> -class CharTraits : public BasicCharTraits < wchar_t > { +class CharTraits : public BasicCharTraits { public: static wchar_t convert(char value) { return value; @@ -556,7 +558,7 @@ struct SignChecker { }; template <> -struct SignChecker < false > { +struct SignChecker { template static bool is_negative(T) { return false; @@ -577,7 +579,7 @@ struct TypeSelector { }; template <> -struct TypeSelector < false > { +struct TypeSelector { typedef uint64_t Type; }; @@ -753,7 +755,7 @@ struct NonZero { }; template <> -struct NonZero < 0 > { +struct NonZero<0> { enum { VALUE = 1 }; }; @@ -814,7 +816,7 @@ struct WCharHelper { }; template -struct WCharHelper < T, wchar_t > { +struct WCharHelper { typedef T Supported; typedef None Unsupported; }; @@ -928,7 +930,7 @@ public: #define FMT_MAKE_WSTR_VALUE(Type, TYPE) \ MakeValue(typename WCharHelper::Supported value) { \ set_string(value); \ - } \ + } \ static uint64_t type(Type) { return Arg::TYPE; } FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING) @@ -942,7 +944,7 @@ public: template MakeValue(const T &value) { custom.value = &value; - custom.format = &format_custom_arg < T > ; + custom.format = &format_custom_arg; } template static uint64_t type(const T &) { @@ -1110,6 +1112,7 @@ public: struct FormatSpec; namespace internal { + class FormatterBase { private: ArgList args_; @@ -1358,26 +1361,26 @@ IntFormatSpec, Char> pad( #define FMT_DEFINE_INT_FORMATTERS(TYPE) \ inline IntFormatSpec > bin(TYPE value) { \ return IntFormatSpec >(value, TypeSpec<'b'>()); \ - } \ + } \ \ inline IntFormatSpec > oct(TYPE value) { \ return IntFormatSpec >(value, TypeSpec<'o'>()); \ - } \ + } \ \ inline IntFormatSpec > hex(TYPE value) { \ return IntFormatSpec >(value, TypeSpec<'x'>()); \ - } \ + } \ \ inline IntFormatSpec > hexu(TYPE value) { \ return IntFormatSpec >(value, TypeSpec<'X'>()); \ - } \ + } \ \ template \ inline IntFormatSpec > pad( \ IntFormatSpec > f, unsigned width) { \ return IntFormatSpec >( \ f.value(), AlignTypeSpec(width, ' ')); \ - } \ + } \ \ /* For compatibility with older compilers we provide two overloads for pad, */ \ /* one that takes a fill character and one that doesn't. In the future this */ \ @@ -1389,20 +1392,20 @@ inline IntFormatSpec, Char> pad( \ unsigned width, Char fill) { \ return IntFormatSpec, Char>( \ f.value(), AlignTypeSpec(width, fill)); \ - } \ + } \ \ inline IntFormatSpec > pad( \ TYPE value, unsigned width) { \ return IntFormatSpec >( \ value, AlignTypeSpec<0>(width, ' ')); \ - } \ + } \ \ template \ inline IntFormatSpec, Char> pad( \ TYPE value, unsigned width, Char fill) { \ return IntFormatSpec, Char>( \ value, AlignTypeSpec<0>(width, fill)); \ - } + } FMT_DEFINE_INT_FORMATTERS(int) FMT_DEFINE_INT_FORMATTERS(long) @@ -1504,9 +1507,9 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { const fmt::internal::Value values[ \ fmt::internal::NonZero::VALUE] = { \ fmt::internal::MakeValue(args)... \ - }; \ + }; \ func(arg1, ArgList(fmt::internal::make_type(args...), values)); \ - } + } // Defines a variadic constructor. # define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ @@ -1516,9 +1519,9 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { const fmt::internal::Value values[ \ fmt::internal::NonZero::VALUE] = { \ MakeValue(args)... \ - }; \ + }; \ func(arg0, arg1, ArgList(fmt::internal::make_type(args...), values)); \ - } + } #else @@ -1533,7 +1536,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { const fmt::internal::Value vals[] = {FMT_GEN(n, FMT_MAKE_REF)}; \ func(arg1, fmt::ArgList( \ fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), vals)); \ - } + } // Emulates a variadic function returning void on a pre-C++11 compiler. # define FMT_VARIADIC_VOID(func, arg_type) \ @@ -1550,7 +1553,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { const fmt::internal::Value vals[] = {FMT_GEN(n, FMT_MAKE_REF)}; \ func(arg0, arg1, fmt::ArgList( \ fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), vals)); \ - } + } // Emulates a variadic constructor on a pre-C++11 compiler. # define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ @@ -1738,8 +1741,8 @@ private: template void append_float_length(Char *&, T) {} - friend class internal::ArgFormatter < Char > ; - friend class internal::PrintfFormatter < Char > ; + friend class internal::ArgFormatter; + friend class internal::PrintfFormatter; protected: /** @@ -2281,7 +2284,7 @@ accessed as a C string with ``out.c_str()``. \endrst */ template > -class BasicMemoryWriter : public BasicWriter < Char > { +class BasicMemoryWriter : public BasicWriter { private: internal::MemoryBuffer buffer_; From 1150247efa0ebbc491a7ca9944f625340713f395 Mon Sep 17 00:00:00 2001 From: gabime Date: Sat, 21 Mar 2015 13:55:00 +0200 Subject: [PATCH 19/60] astyle --- example/example.cpp | 3 +- include/spdlog/details/async_log_helper.h | 10 +- include/spdlog/details/format.h | 834 ++++++++++++------ .../spdlog/details/pattern_formatter_impl.h | 2 +- 4 files changed, 563 insertions(+), 286 deletions(-) diff --git a/example/example.cpp b/example/example.cpp index 96226e32..d1ffb297 100644 --- a/example/example.cpp +++ b/example/example.cpp @@ -112,7 +112,8 @@ int main(int, char*[]) // Example of user defined class with operator<< class some_class {}; -std::ostream& operator<<(std::ostream& os, const some_class&) { +std::ostream& operator<<(std::ostream& os, const some_class&) +{ return os << "some_class"; } diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 56804259..86acd362 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -64,11 +64,11 @@ class async_log_helper async_msg() = default; ~async_msg() = default; - async_msg(async_msg&& other) SPDLOG_NOEXCEPT: - logger_name(std::move(other.logger_name)), - level(std::move(other.level)), - time(std::move(other.time)), - txt(std::move(other.txt)) +async_msg(async_msg&& other) SPDLOG_NOEXCEPT: + logger_name(std::move(other.logger_name)), + level(std::move(other.level)), + time(std::move(other.time)), + txt(std::move(other.txt)) {} async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h index 9de22521..c993b222 100644 --- a/include/spdlog/details/format.h +++ b/include/spdlog/details/format.h @@ -49,10 +49,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifdef _MSC_VER # include // _BitScanReverse, _BitScanReverse64 -namespace fmt { -namespace internal { +namespace fmt +{ +namespace internal +{ # pragma intrinsic(_BitScanReverse) -inline uint32_t clz(uint32_t x) { +inline uint32_t clz(uint32_t x) +{ unsigned long r = 0; _BitScanReverse(&r, x); return 31 - r; @@ -63,7 +66,8 @@ inline uint32_t clz(uint32_t x) { # pragma intrinsic(_BitScanReverse64) # endif -inline uint32_t clzll(uint64_t x) { +inline uint32_t clzll(uint64_t x) +{ unsigned long r = 0; # ifdef _WIN64 _BitScanReverse64(&r, x); @@ -174,7 +178,8 @@ inline uint32_t clzll(uint64_t x) { TypeName& operator=(const TypeName&) #endif -namespace fmt { +namespace fmt +{ // Fix the warning about long long on older versions of GCC // that don't support the diagnostic pragma. @@ -223,7 +228,8 @@ format(std::string("{}"), 42); \endrst */ template -class BasicStringRef { +class BasicStringRef +{ private: const Char *data_; std::size_t size_; @@ -250,28 +256,33 @@ public: /** Converts a string reference to an `std::string` object. */ - operator std::basic_string() const { + operator std::basic_string() const + { return std::basic_string(data_, size()); } /** Returns the pointer to a C string. */ - const Char *c_str() const { + const Char *c_str() const + { return data_; } /** Returns the string size. */ - std::size_t size() const { + std::size_t size() const + { return size_; } - friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) { + friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) + { return lhs.data_ == rhs.data_; } - friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) { + friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) + { return lhs.data_ != rhs.data_; } }; @@ -282,13 +293,15 @@ typedef BasicStringRef WStringRef; /** A formatting error such as invalid format string. */ -class FormatError : public std::runtime_error { +class FormatError : public std::runtime_error +{ public: explicit FormatError(StringRef message) : std::runtime_error(message.c_str()) {} }; -namespace internal { +namespace internal +{ // The number of characters to store in the MemoryBuffer object itself // to avoid dynamic memory allocation. @@ -297,19 +310,22 @@ enum { INLINE_BUFFER_SIZE = 500 }; #if _SECURE_SCL // Use checked iterator to avoid warnings on MSVC. template -inline stdext::checked_array_iterator make_ptr(T *ptr, std::size_t size) { +inline stdext::checked_array_iterator make_ptr(T *ptr, std::size_t size) +{ return stdext::checked_array_iterator(ptr, size); } #else template -inline T *make_ptr(T *ptr, std::size_t) { +inline T *make_ptr(T *ptr, std::size_t) +{ return ptr; } #endif // A buffer for POD types. It supports a subset of std::vector's operations. template -class Buffer { +class Buffer +{ private: FMT_DISALLOW_COPY_AND_ASSIGN(Buffer); @@ -327,31 +343,36 @@ public: virtual ~Buffer() {} // Returns the size of this buffer. - std::size_t size() const { + std::size_t size() const + { return size_; } // Returns the capacity of this buffer. - std::size_t capacity() const { + std::size_t capacity() const + { return capacity_; } // Resizes the buffer. If T is a POD type new elements are not initialized. - void resize(std::size_t new_size) { + void resize(std::size_t new_size) + { if (new_size > capacity_) grow(new_size); size_ = new_size; } // Reserves space to store at least capacity elements. - void reserve(std::size_t capacity) { + void reserve(std::size_t capacity) + { if (capacity > capacity_) grow(capacity); } - void clear() FMT_NOEXCEPT{ size_ = 0; } + void clear() FMT_NOEXCEPT { size_ = 0; } - void push_back(const T &value) { + void push_back(const T &value) + { if (size_ == capacity_) grow(size_ + 1); ptr_[size_++] = value; @@ -360,16 +381,19 @@ public: // Appends data to the end of the buffer. void append(const T *begin, const T *end); - T &operator[](std::size_t index) { + T &operator[](std::size_t index) + { return ptr_[index]; } - const T &operator[](std::size_t index) const { + const T &operator[](std::size_t index) const + { return ptr_[index]; } }; template -void Buffer::append(const T *begin, const T *end) { +void Buffer::append(const T *begin, const T *end) +{ std::ptrdiff_t num_elements = end - begin; if (size_ + num_elements > capacity_) grow(size_ + num_elements); @@ -380,12 +404,14 @@ void Buffer::append(const T *begin, const T *end) { // A memory buffer for POD types with the first SIZE elements stored in // the object itself. template > -class MemoryBuffer : private Allocator, public Buffer { +class MemoryBuffer : private Allocator, public Buffer +{ private: T data_[SIZE]; // Free memory allocated by the buffer. - void free() { + void free() + { if (this->ptr_ != data_) this->deallocate(this->ptr_, this->capacity_); } @@ -395,24 +421,28 @@ protected: public: explicit MemoryBuffer(const Allocator &alloc = Allocator()) : Allocator(alloc), Buffer(data_, SIZE) {} - ~MemoryBuffer() { + ~MemoryBuffer() + { free(); } #if FMT_USE_RVALUE_REFERENCES private: // Move data from other to this buffer. - void move(MemoryBuffer &other) { + void move(MemoryBuffer &other) + { Allocator &this_alloc = *this, &other_alloc = other; this_alloc = std::move(other_alloc); this->size_ = other.size_; this->capacity_ = other.capacity_; - if (other.ptr_ == other.data_) { + if (other.ptr_ == other.data_) + { this->ptr_ = data_; std::copy(other.data_, other.data_ + this->size_, make_ptr(data_, this->capacity_)); } - else { + else + { this->ptr_ = other.ptr_; // Set pointer to the inline array so that delete is not called // when freeing. @@ -421,11 +451,13 @@ private: } public: - MemoryBuffer(MemoryBuffer &&other) { + MemoryBuffer(MemoryBuffer &&other) + { move(other); } - MemoryBuffer &operator=(MemoryBuffer &&other) { + MemoryBuffer &operator=(MemoryBuffer &&other) + { assert(this != &other); free(); move(other); @@ -434,13 +466,15 @@ public: #endif // Returns a copy of the allocator associated with this buffer. - Allocator get_allocator() const { + Allocator get_allocator() const + { return *this; } }; template -void MemoryBuffer::grow(std::size_t size) { +void MemoryBuffer::grow(std::size_t size) +{ std::size_t new_capacity = (std::max)(size, this->capacity_ + this->capacity_ / 2); T *new_ptr = this->allocate(new_capacity); @@ -460,7 +494,8 @@ void MemoryBuffer::grow(std::size_t size) { #ifndef _MSC_VER // Portable version of signbit. -inline int getsign(double x) { +inline int getsign(double x) +{ // When compiled in C++11 mode signbit is no longer a macro but a function // defined in namespace std and the macro is undefined. # ifdef signbit @@ -472,22 +507,27 @@ inline int getsign(double x) { // Portable version of isinf. # ifdef isinf -inline int isinfinity(double x) { +inline int isinfinity(double x) +{ return isinf(x); } -inline int isinfinity(long double x) { +inline int isinfinity(long double x) +{ return isinf(x); } # else -inline int isinfinity(double x) { +inline int isinfinity(double x) +{ return std::isinf(x); } -inline int isinfinity(long double x) { +inline int isinfinity(long double x) +{ return std::isinf(x); } # endif #else -inline int getsign(double value) { +inline int getsign(double value) +{ if (value < 0) return 1; if (value == value) return 0; int dec = 0, sign = 0; @@ -495,16 +535,19 @@ inline int getsign(double value) { _ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign); return sign; } -inline int isinfinity(double x) { +inline int isinfinity(double x) +{ return !_finite(x); } -inline int isinfinity(long double x) { +inline int isinfinity(long double x) +{ return !_finite(static_cast(x)); } #endif template -class BasicCharTraits { +class BasicCharTraits +{ public: #if _SECURE_SCL typedef stdext::checked_array_iterator CharPtr; @@ -517,13 +560,15 @@ template class CharTraits; template <> -class CharTraits : public BasicCharTraits { +class CharTraits : public BasicCharTraits +{ private: // Conversion from wchar_t to char is not allowed. static char convert(wchar_t); public: - static char convert(char value) { + static char convert(char value) + { return value; } @@ -534,12 +579,15 @@ public: }; template <> -class CharTraits : public BasicCharTraits { +class CharTraits : public BasicCharTraits +{ public: - static wchar_t convert(char value) { + static wchar_t convert(char value) + { return value; } - static wchar_t convert(wchar_t value) { + static wchar_t convert(wchar_t value) + { return value; } @@ -550,17 +598,21 @@ public: // Checks if a number is negative - used to avoid warnings. template -struct SignChecker { +struct SignChecker +{ template - static bool is_negative(T value) { + static bool is_negative(T value) + { return value < 0; } }; template <> -struct SignChecker { +struct SignChecker +{ template - static bool is_negative(T) { + static bool is_negative(T) + { return false; } }; @@ -568,23 +620,27 @@ struct SignChecker { // Returns true if value is negative, false otherwise. // Same as (value < 0) but doesn't produce warnings if T is an unsigned type. template -inline bool is_negative(T value) { +inline bool is_negative(T value) +{ return SignChecker::is_signed>::is_negative(value); } // Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise. template -struct TypeSelector { +struct TypeSelector +{ typedef uint32_t Type; }; template <> -struct TypeSelector { +struct TypeSelector +{ typedef uint64_t Type; }; template -struct IntTraits { +struct IntTraits +{ // Smallest of uint32_t and uint64_t that is large enough to represent // all values of T. typedef typename @@ -593,7 +649,8 @@ struct IntTraits { // MakeUnsigned::Type gives an unsigned type corresponding to integer type T. template -struct MakeUnsigned { +struct MakeUnsigned +{ typedef T Type; }; @@ -613,7 +670,8 @@ void report_unknown_type(char code, const char *type); // Static data is placed in this class template to allow header-only // configuration. template -struct BasicData { +struct BasicData +{ static const uint32_t POWERS_OF_10_32[]; static const uint64_t POWERS_OF_10_64[]; static const char DIGITS[]; @@ -632,7 +690,8 @@ typedef BasicData<> Data; #ifdef FMT_BUILTIN_CLZLL // Returns the number of decimal digits in n. Leading zeros are not counted // except for n == 0 in which case count_digits returns 1. -inline unsigned count_digits(uint64_t n) { +inline unsigned count_digits(uint64_t n) +{ // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; @@ -640,9 +699,11 @@ inline unsigned count_digits(uint64_t n) { } #else // Fallback version of count_digits used when __builtin_clz is not available. -inline unsigned count_digits(uint64_t n) { +inline unsigned count_digits(uint64_t n) +{ unsigned count = 1; - for (;;) { + for (;;) + { // Integer division is slow so do it for a group of four digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. @@ -658,7 +719,8 @@ inline unsigned count_digits(uint64_t n) { #ifdef FMT_BUILTIN_CLZ // Optional version of count_digits for better performance on 32-bit platforms. -inline unsigned count_digits(uint32_t n) { +inline unsigned count_digits(uint32_t n) +{ uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; return t - (n < Data::POWERS_OF_10_32[t]) + 1; } @@ -666,9 +728,11 @@ inline unsigned count_digits(uint32_t n) { // Formats a decimal unsigned integer value writing into buffer. template -inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { +inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) +{ --num_digits; - while (value >= 100) { + while (value >= 100) + { // Integer division is slow so do it for a group of two digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. @@ -678,7 +742,8 @@ inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { buffer[num_digits - 1] = Data::DIGITS[index]; num_digits -= 2; } - if (value < 10) { + if (value < 10) + { *buffer = static_cast('0' + value); return; } @@ -690,45 +755,55 @@ inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { #ifdef _WIN32 // A converter from UTF-8 to UTF-16. // It is only provided for Windows since other systems support UTF-8 natively. -class UTF8ToUTF16 { +class UTF8ToUTF16 +{ private: MemoryBuffer buffer_; public: explicit UTF8ToUTF16(StringRef s); - operator WStringRef() const { + operator WStringRef() const + { return WStringRef(&buffer_[0], size()); } - size_t size() const { + size_t size() const + { return buffer_.size() - 1; } - const wchar_t *c_str() const { + const wchar_t *c_str() const + { return &buffer_[0]; } - std::wstring str() const { + std::wstring str() const + { return std::wstring(&buffer_[0], size()); } }; // A converter from UTF-16 to UTF-8. // It is only provided for Windows since other systems support UTF-8 natively. -class UTF16ToUTF8 { +class UTF16ToUTF8 +{ private: MemoryBuffer buffer_; public: UTF16ToUTF8() {} explicit UTF16ToUTF8(WStringRef s); - operator StringRef() const { + operator StringRef() const + { return StringRef(&buffer_[0], size()); } - size_t size() const { + size_t size() const + { return buffer_.size() - 1; } - const char *c_str() const { + const char *c_str() const + { return &buffer_[0]; } - std::string str() const { + std::string str() const + { return std::string(&buffer_[0], size()); } @@ -750,20 +825,24 @@ void format_windows_error(fmt::Writer &out, int error_code, // Computes max(Arg, 1) at compile time. It is used to avoid errors about // allocating an array of 0 size. template -struct NonZero { +struct NonZero +{ enum { VALUE = Arg }; }; template <> -struct NonZero<0> { +struct NonZero<0> +{ enum { VALUE = 1 }; }; // The value of a formatting argument. It is a POD type to allow storage in // internal::MemoryBuffer. -struct Value { +struct Value +{ template - struct StringValue { + struct StringValue + { const Char *value; std::size_t size; }; @@ -771,12 +850,14 @@ struct Value { typedef void(*FormatFunc)( void *formatter, const void *arg, void *format_str_ptr); - struct CustomValue { + struct CustomValue + { const void *value; FormatFunc format; }; - union { + union + { int int_value; unsigned uint_value; LongLong long_long_value; @@ -792,8 +873,10 @@ struct Value { }; }; -struct Arg : Value { - enum Type { +struct Arg : Value +{ + enum Type + { NONE, // Integer types should go first, INT, UINT, LONG_LONG, ULONG_LONG, CHAR, LAST_INTEGER_TYPE = CHAR, @@ -810,20 +893,23 @@ struct None {}; // A helper class template to enable or disable overloads taking wide // characters and strings in MakeValue. template -struct WCharHelper { +struct WCharHelper +{ typedef None Supported; typedef T Unsupported; }; template -struct WCharHelper { +struct WCharHelper +{ typedef T Supported; typedef None Unsupported; }; // Makes a Value object from any type. template -class MakeValue : public Value { +class MakeValue : public Value +{ private: // The following two methods are private to disallow formatting of // arbitrary pointers. If you want to output a pointer cast it to @@ -845,12 +931,14 @@ private: MakeValue(typename WCharHelper::Unsupported); MakeValue(typename WCharHelper::Unsupported); - void set_string(StringRef str) { + void set_string(StringRef str) + { string.value = str.c_str(); string.size = str.size(); } - void set_string(WStringRef str) { + void set_string(WStringRef str) + { wstring.value = str.c_str(); wstring.size = str.size(); } @@ -858,7 +946,8 @@ private: // Formats an argument of a custom type, such as a user-defined class. template static void format_custom_arg( - void *formatter, const void *arg, void *format_str_ptr) { + void *formatter, const void *arg, void *format_str_ptr) + { format(*static_cast*>(formatter), *static_cast(format_str_ptr), *static_cast(arg)); @@ -877,7 +966,8 @@ public: FMT_MAKE_VALUE(int, int_value, INT) FMT_MAKE_VALUE(unsigned, uint_value, UINT) - MakeValue(long value) { + MakeValue(long value) + { // To minimize the number of types we need to deal with, long is // translated either to int or to long long depending on its size. if (sizeof(long) == sizeof(int)) @@ -885,17 +975,20 @@ public: else long_long_value = value; } - static uint64_t type(long) { + static uint64_t type(long) + { return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG; } - MakeValue(unsigned long value) { + MakeValue(unsigned long value) + { if (sizeof(unsigned long) == sizeof(unsigned)) uint_value = static_cast(value); else ulong_long_value = value; } - static uint64_t type(unsigned long) { + static uint64_t type(unsigned long) + { return sizeof(unsigned long) == sizeof(unsigned) ? Arg::UINT : Arg::ULONG_LONG; } @@ -909,10 +1002,12 @@ public: FMT_MAKE_VALUE(unsigned char, int_value, CHAR) FMT_MAKE_VALUE(char, int_value, CHAR) - MakeValue(typename WCharHelper::Supported value) { + MakeValue(typename WCharHelper::Supported value) + { int_value = value; } - static uint64_t type(wchar_t) { + static uint64_t type(wchar_t) + { return Arg::CHAR; } @@ -942,12 +1037,14 @@ public: FMT_MAKE_VALUE(const void *, pointer, POINTER) template - MakeValue(const T &value) { + MakeValue(const T &value) + { custom.value = &value; custom.format = &format_custom_arg; } template - static uint64_t type(const T &) { + static uint64_t type(const T &) + { return Arg::CUSTOM; } }; @@ -975,58 +1072,75 @@ public: // ArgVisitor uses the curiously recurring template pattern: // http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern template -class ArgVisitor { +class ArgVisitor +{ public: - Result visit_unhandled_arg() { + Result visit_unhandled_arg() + { return Result(); } - Result visit_int(int value) { + Result visit_int(int value) + { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_long_long(LongLong value) { + Result visit_long_long(LongLong value) + { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_uint(unsigned value) { + Result visit_uint(unsigned value) + { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_ulong_long(ULongLong value) { + Result visit_ulong_long(ULongLong value) + { return FMT_DISPATCH(visit_any_int(value)); } - Result visit_char(int value) { + Result visit_char(int value) + { return FMT_DISPATCH(visit_any_int(value)); } template - Result visit_any_int(T) { + Result visit_any_int(T) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_double(double value) { + Result visit_double(double value) + { return FMT_DISPATCH(visit_any_double(value)); } - Result visit_long_double(long double value) { + Result visit_long_double(long double value) + { return FMT_DISPATCH(visit_any_double(value)); } template - Result visit_any_double(T) { + Result visit_any_double(T) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_string(Arg::StringValue) { + Result visit_string(Arg::StringValue) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_wstring(Arg::StringValue) { + Result visit_wstring(Arg::StringValue) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_pointer(const void *) { + Result visit_pointer(const void *) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit_custom(Arg::CustomValue) { + Result visit_custom(Arg::CustomValue) + { return FMT_DISPATCH(visit_unhandled_arg()); } - Result visit(const Arg &arg) { - switch (arg.type) { + Result visit(const Arg &arg) + { + switch (arg.type) + { default: assert(false); return Result(); @@ -1044,7 +1158,8 @@ public: return FMT_DISPATCH(visit_long_double(arg.long_double_value)); case Arg::CHAR: return FMT_DISPATCH(visit_char(arg.int_value)); - case Arg::CSTRING: { + case Arg::CSTRING: + { Value::StringValue str = arg.string; str.size = 0; return FMT_DISPATCH(visit_string(str)); @@ -1061,7 +1176,8 @@ public: } }; -class RuntimeError : public std::runtime_error { +class RuntimeError : public std::runtime_error +{ protected: RuntimeError() : std::runtime_error("") {} }; @@ -1073,7 +1189,8 @@ class ArgFormatter; /** An argument list. */ -class ArgList { +class ArgList +{ private: uint64_t types_; const internal::Value *values_; @@ -1089,10 +1206,12 @@ public: /** Returns the argument at specified index. */ - internal::Arg operator[](unsigned index) const { + internal::Arg operator[](unsigned index) const + { using internal::Arg; Arg arg; - if (index >= MAX_ARGS) { + if (index >= MAX_ARGS) + { arg.type = Arg::NONE; return arg; } @@ -1101,7 +1220,8 @@ public: Arg::Type type = static_cast((types_ & (mask << shift)) >> shift); arg.type = type; - if (type != Arg::NONE) { + if (type != Arg::NONE) + { internal::Value &value = arg; value = values_[index]; } @@ -1111,9 +1231,11 @@ public: struct FormatSpec; -namespace internal { +namespace internal +{ -class FormatterBase { +class FormatterBase +{ private: ArgList args_; int next_arg_index_; @@ -1122,7 +1244,8 @@ private: Arg do_get_arg(unsigned arg_index, const char *&error); protected: - void set_args(const ArgList &args) { + void set_args(const ArgList &args) + { args_ = args; next_arg_index_ = 0; } @@ -1135,7 +1258,8 @@ protected: Arg get_arg(unsigned arg_index, const char *&error); template - void write(BasicWriter &w, const Char *start, const Char *end) { + void write(BasicWriter &w, const Char *start, const Char *end) + { if (start != end) w << BasicStringRef(start, end - start); } @@ -1143,7 +1267,8 @@ protected: // A printf formatter. template -class PrintfFormatter : private FormatterBase { +class PrintfFormatter : private FormatterBase +{ private: void parse_flags(FormatSpec &spec, const Char *&s); @@ -1163,7 +1288,8 @@ public: // A formatter. template -class BasicFormatter : private internal::FormatterBase { +class BasicFormatter : private internal::FormatterBase +{ private: BasicWriter &writer_; const Char *start_; @@ -1176,7 +1302,8 @@ private: public: explicit BasicFormatter(BasicWriter &w) : writer_(w) {} - BasicWriter &writer() { + BasicWriter &writer() + { return writer_; } @@ -1185,12 +1312,14 @@ public: const Char *format(const Char *&format_str, const internal::Arg &arg); }; -enum Alignment { +enum Alignment +{ ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC }; // Flags. -enum { +enum +{ SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8, CHAR_FLAG = 0x10 // Argument has char type - used in error reporting. }; @@ -1200,29 +1329,37 @@ struct EmptySpec {}; // A type specifier. template -struct TypeSpec : EmptySpec { - Alignment align() const { +struct TypeSpec : EmptySpec +{ + Alignment align() const + { return ALIGN_DEFAULT; } - unsigned width() const { + unsigned width() const + { return 0; } - int precision() const { + int precision() const + { return -1; } - bool flag(unsigned) const { + bool flag(unsigned) const + { return false; } - char type() const { + char type() const + { return TYPE; } - char fill() const { + char fill() const + { return ' '; } }; // A width specifier. -struct WidthSpec { +struct WidthSpec +{ unsigned width_; // Fill is always wchar_t and cast to char if necessary to avoid having // two specialization of WidthSpec and its subclasses. @@ -1230,45 +1367,54 @@ struct WidthSpec { WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {} - unsigned width() const { + unsigned width() const + { return width_; } - wchar_t fill() const { + wchar_t fill() const + { return fill_; } }; // An alignment specifier. -struct AlignSpec : WidthSpec { +struct AlignSpec : WidthSpec +{ Alignment align_; AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT) : WidthSpec(width, fill), align_(align) {} - Alignment align() const { + Alignment align() const + { return align_; } - int precision() const { + int precision() const + { return -1; } }; // An alignment and type specifier. template -struct AlignTypeSpec : AlignSpec { +struct AlignTypeSpec : AlignSpec +{ AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {} - bool flag(unsigned) const { + bool flag(unsigned) const + { return false; } - char type() const { + char type() const + { return TYPE; } }; // A full format specifier. -struct FormatSpec : AlignSpec { +struct FormatSpec : AlignSpec +{ unsigned flags_; int precision_; char type_; @@ -1277,20 +1423,24 @@ struct FormatSpec : AlignSpec { unsigned width = 0, char type = 0, wchar_t fill = ' ') : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {} - bool flag(unsigned f) const { + bool flag(unsigned f) const + { return (flags_ & f) != 0; } - int precision() const { + int precision() const + { return precision_; } - char type() const { + char type() const + { return type_; } }; // An integer format specifier. template , typename Char = char> -class IntFormatSpec : public SpecT { +class IntFormatSpec : public SpecT +{ private: T value_; @@ -1298,14 +1448,16 @@ public: IntFormatSpec(T val, const SpecT &spec = SpecT()) : SpecT(spec), value_(val) {} - T value() const { + T value() const + { return value_; } }; // A string format specifier. template -class StrFormatSpec : public AlignSpec { +class StrFormatSpec : public AlignSpec +{ private: const T *str_; @@ -1313,7 +1465,8 @@ public: StrFormatSpec(const T *str, unsigned width, wchar_t fill) : AlignSpec(width, fill), str_(str) {} - const T *str() const { + const T *str() const + { return str_; } }; @@ -1428,12 +1581,14 @@ std::string s = str(MemoryWriter() << pad("abc", 8)); */ template inline StrFormatSpec pad( - const Char *str, unsigned width, Char fill = ' ') { + const Char *str, unsigned width, Char fill = ' ') +{ return StrFormatSpec(str, width, fill); } inline StrFormatSpec pad( - const wchar_t *str, unsigned width, char fill = ' ') { + const wchar_t *str, unsigned width, char fill = ' ') +{ return StrFormatSpec(str, width, fill); } @@ -1456,24 +1611,29 @@ inline StrFormatSpec pad( # define FMT_GEN14(f) FMT_GEN13(f), f(13) # define FMT_GEN15(f) FMT_GEN14(f), f(14) -namespace internal { -inline uint64_t make_type() { +namespace internal +{ +inline uint64_t make_type() +{ return 0; } template -inline uint64_t make_type(const T &arg) { +inline uint64_t make_type(const T &arg) +{ return MakeValue::type(arg); } #if FMT_USE_VARIADIC_TEMPLATES template -inline uint64_t make_type(const Arg &first, const Args & ... tail) { +inline uint64_t make_type(const Arg &first, const Args & ... tail) +{ return make_type(first) | (make_type(tail...) << 4); } #else -struct ArgType { +struct ArgType +{ uint64_t type; ArgType() : type(0) {} @@ -1484,7 +1644,8 @@ struct ArgType { # define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType() -inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { +inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) +{ return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) | (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) | (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) | @@ -1595,7 +1756,8 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { An error returned by an operating system or a language runtime, for example a file opening error. */ -class SystemError : public internal::RuntimeError { +class SystemError : public internal::RuntimeError +{ private: void init(int err_code, StringRef format_str, ArgList args); @@ -1632,12 +1794,14 @@ public: throw fmt::SystemError(errno, "cannot open file '{}'", filename); \endrst */ - SystemError(int error_code, StringRef message) { + SystemError(int error_code, StringRef message) + { init(error_code, message, ArgList()); } FMT_VARIADIC_CTOR(SystemError, init, int, StringRef) - int error_code() const { + int error_code() const + { return error_code_; } }; @@ -1661,7 +1825,8 @@ You can use one of the following typedefs for common character types: \endrst */ template -class BasicWriter { +class BasicWriter +{ private: // Output buffer. internal::Buffer &buffer_; @@ -1672,11 +1837,13 @@ private: #if _SECURE_SCL // Returns pointer value. - static Char *get(CharPtr p) { + static Char *get(CharPtr p) + { return p.base(); } #else - static Char *get(Char *p) { + static Char *get(Char *p) + { return p; } #endif @@ -1688,7 +1855,8 @@ private: // Grows the buffer by n characters and returns a pointer to the newly // allocated area. - CharPtr grow_buffer(std::size_t n) { + CharPtr grow_buffer(std::size_t n) + { std::size_t size = buffer_.size(); buffer_.resize(size + n); return internal::make_ptr(&buffer_[size], n); @@ -1696,7 +1864,8 @@ private: // Prepare a buffer for integer formatting. CharPtr prepare_int_buffer(unsigned num_digits, - const EmptySpec &, const char *prefix, unsigned prefix_size) { + const EmptySpec &, const char *prefix, unsigned prefix_size) + { unsigned size = prefix_size + num_digits; CharPtr p = grow_buffer(size); std::copy(prefix, prefix + prefix_size, p); @@ -1734,7 +1903,8 @@ private: // Appends floating-point length specifier to the format string. // The second argument is only used for overload resolution. - void append_float_length(Char *&format_ptr, long double) { + void append_float_length(Char *&format_ptr, long double) + { *format_ptr++ = 'L'; } @@ -1759,7 +1929,8 @@ public: /** Returns the total number of characters written. */ - std::size_t size() const { + std::size_t size() const + { return buffer_.size(); } @@ -1767,7 +1938,8 @@ public: Returns a pointer to the output buffer content. No terminating null character is appended. */ - const Char *data() const FMT_NOEXCEPT { + const Char *data() const FMT_NOEXCEPT + { return &buffer_[0]; } @@ -1775,7 +1947,8 @@ public: Returns a pointer to the output buffer content with terminating null character appended. */ - const Char *c_str() const { + const Char *c_str() const + { std::size_t size = buffer_.size(); buffer_.reserve(size + 1); buffer_[size] = '\0'; @@ -1785,7 +1958,8 @@ public: /** Returns the content of the output buffer as an `std::string`. */ - std::basic_string str() const { + std::basic_string str() const + { return std::basic_string(&buffer_[0], buffer_.size()); } @@ -1814,35 +1988,43 @@ public: See also :ref:`syntax`. \endrst */ - void write(BasicStringRef format, ArgList args) { + void write(BasicStringRef format, ArgList args) + { BasicFormatter(*this).format(format, args); } FMT_VARIADIC_VOID(write, BasicStringRef) - BasicWriter &operator<<(int value) { + BasicWriter &operator<<(int value) + { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(unsigned value) { + BasicWriter &operator<<(unsigned value) + { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(long value) { + BasicWriter &operator<<(long value) + { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(unsigned long value) { + BasicWriter &operator<<(unsigned long value) + { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(LongLong value) { + BasicWriter &operator<<(LongLong value) + { return *this << IntFormatSpec(value); } /** Formats *value* and writes it to the stream. */ - BasicWriter &operator<<(ULongLong value) { + BasicWriter &operator<<(ULongLong value) + { return *this << IntFormatSpec(value); } - BasicWriter &operator<<(double value) { + BasicWriter &operator<<(double value) + { write_double(value, FormatSpec()); return *this; } @@ -1851,7 +2033,8 @@ public: Formats *value* using the general format for floating-point numbers (``'g'``) and writes it to the stream. */ - BasicWriter &operator<<(long double value) { + BasicWriter &operator<<(long double value) + { write_double(value, FormatSpec()); return *this; } @@ -1859,13 +2042,15 @@ public: /** Writes a character to the stream. */ - BasicWriter &operator<<(char value) { + BasicWriter &operator<<(char value) + { buffer_.push_back(value); return *this; } BasicWriter &operator<<( - typename internal::WCharHelper::Supported value) { + typename internal::WCharHelper::Supported value) + { buffer_.push_back(value); return *this; } @@ -1873,50 +2058,59 @@ public: /** Writes *value* to the stream. */ - BasicWriter &operator<<(fmt::BasicStringRef value) { + BasicWriter &operator<<(fmt::BasicStringRef value) + { const Char *str = value.c_str(); buffer_.append(str, str + value.size()); return *this; } template - BasicWriter &operator<<(IntFormatSpec spec) { + BasicWriter &operator<<(IntFormatSpec spec) + { internal::CharTraits::convert(FillChar()); write_int(spec.value(), spec); return *this; } template - BasicWriter &operator<<(const StrFormatSpec &spec) { + BasicWriter &operator<<(const StrFormatSpec &spec) + { const StrChar *s = spec.str(); // TODO: error if fill is not convertible to Char write_str(s, std::char_traits::length(s), spec); return *this; } - void clear() FMT_NOEXCEPT{ buffer_.clear(); } + void clear() FMT_NOEXCEPT { buffer_.clear(); } }; template template typename BasicWriter::CharPtr BasicWriter::write_str( - const StrChar *s, std::size_t size, const AlignSpec &spec) { + const StrChar *s, std::size_t size, const AlignSpec &spec) +{ CharPtr out = CharPtr(); - if (spec.width() > size) { + if (spec.width() > size) + { out = grow_buffer(spec.width()); Char fill = static_cast(spec.fill()); - if (spec.align() == ALIGN_RIGHT) { + if (spec.align() == ALIGN_RIGHT) + { std::fill_n(out, spec.width() - size, fill); out += spec.width() - size; } - else if (spec.align() == ALIGN_CENTER) { + else if (spec.align() == ALIGN_CENTER) + { out = fill_padding(out, spec.width(), size, fill); } - else { + else + { std::fill_n(out + size, spec.width() - size, fill); } } - else { + else + { out = grow_buffer(size); } std::copy(s, s + size, out); @@ -1927,7 +2121,8 @@ template typename BasicWriter::CharPtr BasicWriter::fill_padding( CharPtr buffer, unsigned total_size, - std::size_t content_size, wchar_t fill) { + std::size_t content_size, wchar_t fill) +{ std::size_t padding = total_size - content_size; std::size_t left_padding = padding / 2; Char fill_char = static_cast(fill); @@ -1943,11 +2138,13 @@ template typename BasicWriter::CharPtr BasicWriter::prepare_int_buffer( unsigned num_digits, const Spec &spec, - const char *prefix, unsigned prefix_size) { + const char *prefix, unsigned prefix_size) +{ unsigned width = spec.width(); Alignment align = spec.align(); Char fill = static_cast(spec.fill()); - if (spec.precision() > static_cast(num_digits)) { + if (spec.precision() > static_cast(num_digits)) + { // Octal prefix '0' is counted as a digit, so ignore it if precision // is specified. if (prefix_size > 0 && prefix[prefix_size - 1] == '0') @@ -1958,44 +2155,53 @@ BasicWriter::prepare_int_buffer( return prepare_int_buffer(num_digits, subspec, prefix, prefix_size); buffer_.reserve(width); unsigned fill_size = width - number_size; - if (align != ALIGN_LEFT) { + if (align != ALIGN_LEFT) + { CharPtr p = grow_buffer(fill_size); std::fill(p, p + fill_size, fill); } CharPtr result = prepare_int_buffer( num_digits, subspec, prefix, prefix_size); - if (align == ALIGN_LEFT) { + if (align == ALIGN_LEFT) + { CharPtr p = grow_buffer(fill_size); std::fill(p, p + fill_size, fill); } return result; } unsigned size = prefix_size + num_digits; - if (width <= size) { + if (width <= size) + { CharPtr p = grow_buffer(size); std::copy(prefix, prefix + prefix_size, p); return p + size - 1; } CharPtr p = grow_buffer(width); CharPtr end = p + width; - if (align == ALIGN_LEFT) { + if (align == ALIGN_LEFT) + { std::copy(prefix, prefix + prefix_size, p); p += size; std::fill(p, end, fill); } - else if (align == ALIGN_CENTER) { + else if (align == ALIGN_CENTER) + { p = fill_padding(p, width, size, fill); std::copy(prefix, prefix + prefix_size, p); p += size; } - else { - if (align == ALIGN_NUMERIC) { - if (prefix_size != 0) { + else + { + if (align == ALIGN_NUMERIC) + { + if (prefix_size != 0) + { p = std::copy(prefix, prefix + prefix_size, p); size -= prefix_size; } } - else { + else + { std::copy(prefix, prefix + prefix_size, end - size); } std::fill(p, end - size, fill); @@ -2006,23 +2212,28 @@ BasicWriter::prepare_int_buffer( template template -void BasicWriter::write_int(T value, Spec spec) { +void BasicWriter::write_int(T value, Spec spec) +{ unsigned prefix_size = 0; typedef typename internal::IntTraits::MainType UnsignedType; UnsignedType abs_value = value; char prefix[4] = ""; - if (internal::is_negative(value)) { + if (internal::is_negative(value)) + { prefix[0] = '-'; ++prefix_size; abs_value = 0 - abs_value; } - else if (spec.flag(SIGN_FLAG)) { + else if (spec.flag(SIGN_FLAG)) + { prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' '; ++prefix_size; } - switch (spec.type()) { + switch (spec.type()) + { case 0: - case 'd': { + case 'd': + { unsigned num_digits = internal::count_digits(abs_value); CharPtr p = prepare_int_buffer( num_digits, spec, prefix, prefix_size) + 1 - num_digits; @@ -2030,57 +2241,74 @@ void BasicWriter::write_int(T value, Spec spec) { break; } case 'x': - case 'X': { + case 'X': + { UnsignedType n = abs_value; - if (spec.flag(HASH_FLAG)) { + if (spec.flag(HASH_FLAG)) + { prefix[prefix_size++] = '0'; prefix[prefix_size++] = spec.type(); } unsigned num_digits = 0; - do { + do + { ++num_digits; - } while ((n >>= 4) != 0); + } + while ((n >>= 4) != 0); Char *p = get(prepare_int_buffer( num_digits, spec, prefix, prefix_size)); n = abs_value; const char *digits = spec.type() == 'x' ? "0123456789abcdef" : "0123456789ABCDEF"; - do { + do + { *p-- = digits[n & 0xf]; - } while ((n >>= 4) != 0); + } + while ((n >>= 4) != 0); break; } case 'b': - case 'B': { + case 'B': + { UnsignedType n = abs_value; - if (spec.flag(HASH_FLAG)) { + if (spec.flag(HASH_FLAG)) + { prefix[prefix_size++] = '0'; prefix[prefix_size++] = spec.type(); } unsigned num_digits = 0; - do { + do + { ++num_digits; - } while ((n >>= 1) != 0); + } + while ((n >>= 1) != 0); Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); n = abs_value; - do { + do + { *p-- = '0' + (n & 1); - } while ((n >>= 1) != 0); + } + while ((n >>= 1) != 0); break; } - case 'o': { + case 'o': + { UnsignedType n = abs_value; if (spec.flag(HASH_FLAG)) prefix[prefix_size++] = '0'; unsigned num_digits = 0; - do { + do + { ++num_digits; - } while ((n >>= 3) != 0); + } + while ((n >>= 3) != 0); Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); n = abs_value; - do { + do + { *p-- = '0' + (n & 7); - } while ((n >>= 3) != 0); + } + while ((n >>= 3) != 0); break; } default: @@ -2093,11 +2321,13 @@ void BasicWriter::write_int(T value, Spec spec) { template template void BasicWriter::write_double( - T value, const FormatSpec &spec) { + T value, const FormatSpec &spec) +{ // Check type. char type = spec.type(); bool upper = false; - switch (type) { + switch (type) + { case 0: type = 'g'; break; @@ -2111,7 +2341,7 @@ void BasicWriter::write_double( // MSVC's printf doesn't support 'F'. type = 'f'; #endif - // Fall through. + // Fall through. case 'E': case 'G': case 'A': @@ -2125,20 +2355,24 @@ void BasicWriter::write_double( char sign = 0; // Use getsign instead of value < 0 because the latter is always // false for NaN. - if (internal::getsign(static_cast(value))) { + if (internal::getsign(static_cast(value))) + { sign = '-'; value = -value; } - else if (spec.flag(SIGN_FLAG)) { + else if (spec.flag(SIGN_FLAG)) + { sign = spec.flag(PLUS_FLAG) ? '+' : ' '; } - if (value != value) { + if (value != value) + { // Format NaN ourselves because sprintf's output is not consistent // across platforms. std::size_t nan_size = 4; const char *nan = upper ? " NAN" : " nan"; - if (!sign) { + if (!sign) + { --nan_size; ++nan; } @@ -2148,12 +2382,14 @@ void BasicWriter::write_double( return; } - if (internal::isinfinity(value)) { + if (internal::isinfinity(value)) + { // Format infinity ourselves because sprintf's output is not consistent // across platforms. std::size_t inf_size = 4; const char *inf = upper ? " INF" : " inf"; - if (!sign) { + if (!sign) + { --inf_size; ++inf; } @@ -2165,7 +2401,8 @@ void BasicWriter::write_double( std::size_t offset = buffer_.size(); unsigned width = spec.width(); - if (sign) { + if (sign) + { buffer_.reserve(buffer_.size() + (std::max)(width, 1u)); if (width > 0) --width; @@ -2180,16 +2417,19 @@ void BasicWriter::write_double( unsigned width_for_sprintf = width; if (spec.flag(HASH_FLAG)) *format_ptr++ = '#'; - if (spec.align() == ALIGN_CENTER) { + if (spec.align() == ALIGN_CENTER) + { width_for_sprintf = 0; } - else { + else + { if (spec.align() == ALIGN_LEFT) *format_ptr++ = '-'; if (width != 0) *format_ptr++ = '*'; } - if (spec.precision() >= 0) { + if (spec.precision() >= 0) + { *format_ptr++ = '.'; *format_ptr++ = '*'; } @@ -2200,13 +2440,15 @@ void BasicWriter::write_double( // Format using snprintf. Char fill = static_cast(spec.fill()); - for (;;) { + for (;;) + { std::size_t buffer_size = buffer_.capacity() - offset; #if _MSC_VER // MSVC's vsnprintf_s doesn't work with zero size, so reserve // space for at least one extra character to make the size non-zero. // Note that the buffer's capacity will increase by more than 1. - if (buffer_size == 0) { + if (buffer_size == 0) + { buffer_.reserve(offset + 1); buffer_size = buffer_.capacity() - offset; } @@ -2214,27 +2456,33 @@ void BasicWriter::write_double( Char *start = &buffer_[offset]; int n = internal::CharTraits::format_float( start, buffer_size, format, width_for_sprintf, spec.precision(), value); - if (n >= 0 && offset + n < buffer_.capacity()) { - if (sign) { + if (n >= 0 && offset + n < buffer_.capacity()) + { + if (sign) + { if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) || - *start != ' ') { + *start != ' ') + { *(start - 1) = sign; sign = 0; } - else { + else + { *(start - 1) = fill; } ++n; } if (spec.align() == ALIGN_CENTER && - spec.width() > static_cast(n)) { + spec.width() > static_cast(n)) + { width = spec.width(); CharPtr p = grow_buffer(width); std::copy(p, p + n, p + (width - n) / 2); fill_padding(p, spec.width(), n, fill); return; } - if (spec.fill() != ' ' || sign) { + if (spec.fill() != ' ' || sign) + { while (*start == ' ') *start++ = fill; if (sign) @@ -2284,7 +2532,8 @@ accessed as a C string with ``out.c_str()``. \endrst */ template > -class BasicMemoryWriter : public BasicWriter { +class BasicMemoryWriter : public BasicWriter +{ private: internal::MemoryBuffer buffer_; @@ -2298,13 +2547,15 @@ public: of the other object to it. */ BasicMemoryWriter(BasicMemoryWriter &&other) - : BasicWriter(buffer_), buffer_(std::move(other.buffer_)) { + : BasicWriter(buffer_), buffer_(std::move(other.buffer_)) + { } /** Moves the content of the other ``BasicMemoryWriter`` object to this one. */ - BasicMemoryWriter &operator=(BasicMemoryWriter &&other) { + BasicMemoryWriter &operator=(BasicMemoryWriter &&other) + { buffer_ = std::move(other.buffer_); return *this; } @@ -2316,7 +2567,8 @@ typedef BasicMemoryWriter WMemoryWriter; // Formats a value. template -void format(BasicFormatter &f, const Char *&format_str, const T &value) { +void format(BasicFormatter &f, const Char *&format_str, const T &value) +{ std::basic_ostringstream os; os << value; internal::Arg arg; @@ -2335,7 +2587,8 @@ void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT; #ifdef _WIN32 /** A Windows error. */ -class WindowsError : public SystemError { +class WindowsError : public SystemError +{ private: void init(int error_code, StringRef format_str, ArgList args); @@ -2368,7 +2621,8 @@ public: } \endrst */ - WindowsError(int error_code, StringRef message) { + WindowsError(int error_code, StringRef message) + { init(error_code, message, ArgList()); } FMT_VARIADIC_CTOR(WindowsError, init, int, StringRef) @@ -2399,13 +2653,15 @@ Formats arguments and returns the result as a string. std::string message = format("The answer is {}", 42); \endrst */ -inline std::string format(StringRef format_str, ArgList args) { +inline std::string format(StringRef format_str, ArgList args) +{ MemoryWriter w; w.write(format_str, args); return w.str(); } -inline std::wstring format(WStringRef format_str, ArgList args) { +inline std::wstring format(WStringRef format_str, ArgList args) +{ WMemoryWriter w; w.write(format_str, args); return w.str(); @@ -2445,7 +2701,8 @@ print(cerr, "Don't {}!", "panic"); void print(std::ostream &os, StringRef format_str, ArgList args); template -void printf(BasicWriter &w, BasicStringRef format, ArgList args) { +void printf(BasicWriter &w, BasicStringRef format, ArgList args) +{ internal::PrintfFormatter().format(w, format, args); } @@ -2458,7 +2715,8 @@ Formats arguments and returns the result as a string. std::string message = fmt::sprintf("The answer is %d", 42); \endrst */ -inline std::string sprintf(StringRef format, ArgList args) { +inline std::string sprintf(StringRef format, ArgList args) +{ MemoryWriter w; printf(w, format, args); return w.str(); @@ -2484,14 +2742,16 @@ Prints formatted data to ``stdout``. fmt::printf("Elapsed time: %.2f seconds", 1.23); \endrst */ -inline int printf(StringRef format, ArgList args) { +inline int printf(StringRef format, ArgList args) +{ return fprintf(stdout, format, args); } /** Fast integer formatter. */ -class FormatInt { +class FormatInt +{ private: // Buffer should be large enough to hold all digits (digits10 + 1), // a sign and a null character. @@ -2500,9 +2760,11 @@ private: char *str_; // Formats value in reverse and returns the number of digits. - char *format_decimal(ULongLong value) { + char *format_decimal(ULongLong value) + { char *buffer_end = buffer_ + BUFFER_SIZE - 1; - while (value >= 100) { + while (value >= 100) + { // Integer division is slow so do it for a group of two digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. @@ -2511,7 +2773,8 @@ private: *--buffer_end = internal::Data::DIGITS[index + 1]; *--buffer_end = internal::Data::DIGITS[index]; } - if (value < 10) { + if (value < 10) + { *--buffer_end = static_cast('0' + value); return buffer_end; } @@ -2521,7 +2784,8 @@ private: return buffer_end; } - void FormatSigned(LongLong value) { + void FormatSigned(LongLong value) + { ULongLong abs_value = static_cast(value); bool negative = value < 0; if (negative) @@ -2532,13 +2796,16 @@ private: } public: - explicit FormatInt(int value) { + explicit FormatInt(int value) + { FormatSigned(value); } - explicit FormatInt(long value) { + explicit FormatInt(long value) + { FormatSigned(value); } - explicit FormatInt(LongLong value) { + explicit FormatInt(LongLong value) + { FormatSigned(value); } explicit FormatInt(unsigned value) : str_(format_decimal(value)) {} @@ -2548,7 +2815,8 @@ public: /** Returns the number of characters written to the output buffer. */ - std::size_t size() const { + std::size_t size() const + { return buffer_ - str_ + BUFFER_SIZE - 1; } @@ -2556,7 +2824,8 @@ public: Returns a pointer to the output buffer content. No terminating null character is appended. */ - const char *data() const { + const char *data() const + { return str_; } @@ -2564,7 +2833,8 @@ public: Returns a pointer to the output buffer content with terminating null character appended. */ - const char *c_str() const { + const char *c_str() const + { buffer_[BUFFER_SIZE - 1] = '\0'; return str_; } @@ -2572,7 +2842,8 @@ public: /** Returns the content of the output buffer as an `std::string`. */ - std::string str() const { + std::string str() const + { return std::string(str_, size()); } }; @@ -2581,14 +2852,18 @@ public: // a pointer to the end of the formatted string. This function doesn't // write a terminating null character. template -inline void format_decimal(char *&buffer, T value) { +inline void format_decimal(char *&buffer, T value) +{ typename internal::IntTraits::MainType abs_value = value; - if (internal::is_negative(value)) { + if (internal::is_negative(value)) + { *buffer++ = '-'; abs_value = 0 - abs_value; } - if (abs_value < 100) { - if (abs_value < 10) { + if (abs_value < 100) + { + if (abs_value < 10) + { *buffer++ = static_cast('0' + abs_value); return; } @@ -2708,7 +2983,8 @@ fmt::print(format, args...); #define FMT_VARIADIC_W(ReturnType, func, ...) \ FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__) -namespace fmt { +namespace fmt +{ FMT_VARIADIC(std::string, format, StringRef) FMT_VARIADIC_W(std::wstring, format, WStringRef) FMT_VARIADIC(void, print, StringRef) diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index f31b918e..cc9311c5 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -478,7 +478,7 @@ inline void spdlog::pattern_formatter::handle_flag(char flag) { switch (flag) { - // logger name + // logger name case 'n': _formatters.push_back(std::unique_ptr(new details::name_formatter())); break; From 37541621b7f8a95d341fdb1f3ce5bd45f42c4a88 Mon Sep 17 00:00:00 2001 From: Ruslan Mullakhmetov Date: Thu, 26 Mar 2015 14:23:52 +0300 Subject: [PATCH 20/60] added convinient macroses passing logging points; replaced force_log to log for SPDLOG_TRACE SPDLOG_DEBUG --- include/spdlog/spdlog.h | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index cd80a90c..a92277a3 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -131,19 +131,25 @@ std::shared_ptr create(const std::string& logger_name, const Arg // #ifdef SPDLOG_TRACE_ON -#define SPDLOG_TRACE(logger, ...) logger->force_log(spdlog::level::trace, __VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; +#define SPDLOG_TRACE(logger, ...) logger->trace(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; #else #define SPDLOG_TRACE(logger, ...) #endif #ifdef SPDLOG_DEBUG_ON -#define SPDLOG_DEBUG(logger, ...) logger->force_log(spdlog::level::debug, __VA_ARGS__) +#define SPDLOG_DEBUG(logger, ...) logger->debug(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; #else #define SPDLOG_DEBUG(logger, ...) #endif - +#define SPDLOG_INFO(logger, ...) logger->info(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; +#define SPDLOG_NOTICE(logger, ...) logger->notice(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; +#define SPDLOG_WARN(logger, ...) logger->warn(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; +#define SPDLOG_ERROR(logger, ...) logger->err(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; +#define SPDLOG_CRITICAL(logger, ...) logger->critical(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; +#define SPDLOG_ALERT(logger, ...) logger->alert(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; +#define SPDLOG_EMERG(logger, ...) logger->emerg(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; // Drop the reference to the given logger void drop(const std::string &name); From d39b495e215444a3dab4c9438c994782abe5ff2c Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Thu, 26 Mar 2015 18:48:33 +0200 Subject: [PATCH 21/60] Update spdlog.h Updated comments about macros --- include/spdlog/spdlog.h | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index a92277a3..3c9f5a24 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -119,8 +119,10 @@ template std::shared_ptr create(const std::string& logger_name, const Args&...); // -// Trace & debug macros to be switched on/off at compile time for zero cost debug statements. -// Note: using these mactors overrides the runtime log threshold of the logger. +// +// Macros to be display source file & line +// +// Trace & debug can be switched on/off at compile time for zero cost debug statements. // // Example: // @@ -136,7 +138,6 @@ std::shared_ptr create(const std::string& logger_name, const Arg #define SPDLOG_TRACE(logger, ...) #endif - #ifdef SPDLOG_DEBUG_ON #define SPDLOG_DEBUG(logger, ...) logger->debug(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; #else From 9fc0ab31d5b54b544bc47392e5870c5ecdbf7294 Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Thu, 26 Mar 2015 18:51:22 +0200 Subject: [PATCH 22/60] Update spdlog.h Update comments about macros --- include/spdlog/spdlog.h | 24 +++++++++++------------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index 3c9f5a24..78ee7470 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -118,20 +118,24 @@ std::shared_ptr create(const std::string& logger_name, const It& sinks_b template std::shared_ptr create(const std::string& logger_name, const Args&...); + +// Drop the reference to the given logger +void drop(const std::string &name); + +// Drop all references +void drop_all(); + + // // // Macros to be display source file & line -// -// Trace & debug can be switched on/off at compile time for zero cost debug statements. +// Trace & Debug can be switched on/off at compile time for zero cost debug statements. // // Example: -// -// Enable debug macro, must be defined before including spdlog.h -// #define SPDLOG_DEBUG_ON -// include "spdlog/spdlog.h" +// #define SPDLOG_DEBUG_ON +// include "spdlog/spdlog.h" // SPDLOG_DEBUG(my_logger, "Some debug message {} {}", 1, 3.2); // - #ifdef SPDLOG_TRACE_ON #define SPDLOG_TRACE(logger, ...) logger->trace(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; #else @@ -152,12 +156,6 @@ std::shared_ptr create(const std::string& logger_name, const Arg #define SPDLOG_ALERT(logger, ...) logger->alert(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; #define SPDLOG_EMERG(logger, ...) logger->emerg(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; -// Drop the reference to the given logger -void drop(const std::string &name); - -// Drop all references -void drop_all(); - } From 11d4ae7782744a8ea3a9204783069337eae87fab Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Thu, 26 Mar 2015 18:52:03 +0200 Subject: [PATCH 23/60] Update spdlog.h --- include/spdlog/spdlog.h | 5 ----- 1 file changed, 5 deletions(-) diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index 78ee7470..a17b60d7 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -28,16 +28,11 @@ #pragma once - - #include "common.h" #include "logger.h" - - namespace spdlog { - // Return an existing logger or nullptr if a logger with such name doesn't exist. // Examples: // From f21ec29ca945cd5feec43a1681553c3acf689359 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 7 Apr 2015 17:54:16 +0300 Subject: [PATCH 24/60] fixed SPDLOG_ERROR macro --- include/spdlog/spdlog.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index a17b60d7..85ac8205 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -146,7 +146,7 @@ void drop_all(); #define SPDLOG_INFO(logger, ...) logger->info(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; #define SPDLOG_NOTICE(logger, ...) logger->notice(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; #define SPDLOG_WARN(logger, ...) logger->warn(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; -#define SPDLOG_ERROR(logger, ...) logger->err(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; +#define SPDLOG_ERROR(logger, ...) logger->error(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; #define SPDLOG_CRITICAL(logger, ...) logger->critical(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; #define SPDLOG_ALERT(logger, ...) logger->alert(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; #define SPDLOG_EMERG(logger, ...) logger->emerg(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; From 69d71c52a1174ae8167e5ef7b7e3f577d742c5c6 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 7 Apr 2015 19:44:21 +0300 Subject: [PATCH 25/60] removed results.txt --- bench/results.txt | 235 ---------------------------------------------- 1 file changed, 235 deletions(-) delete mode 100644 bench/results.txt diff --git a/bench/results.txt b/bench/results.txt deleted file mode 100644 index fdd5718a..00000000 --- a/bench/results.txt +++ /dev/null @@ -1,235 +0,0 @@ ----------------------------------------------------------- -Single threaded benchmarks.. (1 thread, 1,000,000 lines) ----------------------------------------------------------- -**************** boost-bench **************** - -real 0m4.382s -user 0m4.213s -sys 0m0.048s - -real 0m4.159s -user 0m4.120s -sys 0m0.040s - -real 0m4.169s -user 0m4.117s -sys 0m0.052s -**************** glog-bench **************** - -real 0m1.082s -user 0m0.944s -sys 0m0.136s - -real 0m1.079s -user 0m0.977s -sys 0m0.101s - -real 0m1.066s -user 0m0.951s -sys 0m0.114s -**************** easylogging-bench **************** - -real 0m0.975s -user 0m0.963s -sys 0m0.012s - -real 0m0.986s -user 0m0.954s -sys 0m0.033s - -real 0m0.963s -user 0m0.919s -sys 0m0.044s -**************** spdlog-bench **************** - -real 0m0.302s -user 0m0.285s -sys 0m0.016s - -real 0m0.311s -user 0m0.287s -sys 0m0.025s - -real 0m0.308s -user 0m0.276s -sys 0m0.032s ----------------------------------------------------------- -Multi threaded benchmarks.. (10 threads, 1,000,000 lines) ----------------------------------------------------------- -**************** boost-bench-mt **************** - -real 0m16.293s -user 0m38.723s -sys 0m8.469s - -real 0m16.029s -user 0m39.186s -sys 0m8.413s - -real 0m16.257s -user 0m38.322s -sys 0m7.880s -**************** glog-bench-mt **************** - -real 0m4.455s -user 0m12.871s -sys 0m13.508s - -real 0m5.039s -user 0m14.239s -sys 0m15.900s - -real 0m3.032s -user 0m8.654s -sys 0m9.473s -**************** easylogging-bench-mt **************** - -real 0m4.076s -user 0m4.350s -sys 0m2.861s - -real 0m2.857s -user 0m3.270s -sys 0m1.744s - -real 0m4.588s -user 0m5.085s -sys 0m3.058s -**************** spdlog-bench-mt **************** - -real 0m2.374s -user 0m4.369s -sys 0m10.426s - -real 0m0.968s -user 0m1.804s -sys 0m4.186s - -real 0m1.527s -user 0m3.132s -sys 0m6.427s ----------------------------------------------------------- -Multi threaded benchmarks.. (100 threads, 1,000,000 lines) ----------------------------------------------------------- -**************** boost-bench-mt **************** - -real 0m15.623s -user 0m39.283s -sys 0m8.428s - -real 0m15.008s -user 0m36.851s -sys 0m7.956s - -real 0m15.478s -user 0m38.873s -sys 0m8.368s -**************** glog-bench-mt **************** - -real 0m1.139s -user 0m3.003s -sys 0m5.214s - -real 0m1.167s -user 0m3.004s -sys 0m5.431s - -real 0m1.159s -user 0m2.909s -sys 0m5.456s -**************** easylogging-bench-mt **************** - -real 0m4.510s -user 0m4.565s -sys 0m3.510s - -real 0m8.841s -user 0m8.363s -sys 0m7.057s - -real 0m5.638s -user 0m5.531s -sys 0m4.168s -**************** spdlog-bench-mt **************** - -real 0m0.497s -user 0m0.951s -sys 0m2.743s - -real 0m0.502s -user 0m0.940s -sys 0m2.816s - -real 0m0.504s -user 0m0.911s -sys 0m2.860s ---------------------------------------------------------------- -Async, single threaded benchmark.. (1 thread, 1,000,000 lines) ---------------------------------------------------------------- -**************** spdlog-async **************** -Total: 1000000 -Threads: 1 -Delta = 0.216366 seconds -Rate = 4.62179e+06/sec -Total: 1000000 -Threads: 1 -Delta = 0.215076 seconds -Rate = 4.64953e+06/sec -Total: 1000000 -Threads: 1 -Delta = 0.210712 seconds -Rate = 4.74581e+06/sec -**************** g2log-async **************** -Total: 1000000 -Threads: 1 -Delta = 1.85039 seconds -Rate = 540428/sec - -Exiting, log location: logs/g2log-async.g2log.20141220-214929.log -Total: 1000000 -Threads: 1 -Delta = 1.85434 seconds -Rate = 539274/sec - -Exiting, log location: logs/g2log-async.g2log.20141220-214935.log -Total: 1000000 -Threads: 1 -Delta = 1.86829 seconds -Rate = 535249/sec - -Exiting, log location: logs/g2log-async.g2log.20141220-214941.log ---------------------------------------------------------------- -Async, multi threaded benchmark.. (10 threads, 1,000,000 lines) ---------------------------------------------------------------- -**************** spdlog-async **************** -Total: 1000000 -Threads: 10 -Delta = 0.175684 seconds -Rate = 5.69204e+06/sec -Total: 1000000 -Threads: 10 -Delta = 0.173104 seconds -Rate = 5.77688e+06/sec -Total: 1000000 -Threads: 10 -Delta = 0.173881 seconds -Rate = 5.75106e+06/sec -**************** g2log-async **************** -Total: 1000000 -Threads: 10 -Delta = 0.945252 seconds -Rate = 1.05792e+06/sec - -Exiting, log location: logs/g2log-async.g2log.20141220-214958.log -Total: 1000000 -Threads: 10 -Delta = 0.950362 seconds -Rate = 1.05223e+06/sec - -Exiting, log location: logs/g2log-async.g2log.20141220-215004.log -Total: 1000000 -Threads: 10 -Delta = 0.943302 seconds -Rate = 1.06011e+06/sec - -Exiting, log location: logs/g2log-async.g2log.20141220-215011.log From acb06ea9770f0f6e7667af3bd182e413a4400292 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 7 Apr 2015 19:57:27 +0300 Subject: [PATCH 26/60] Fixed thread id bug in async mode by passing thread id in log_msg struct --- include/spdlog/details/async_log_helper.h | 2 ++ include/spdlog/details/line_logger.h | 3 ++- include/spdlog/details/log_msg.h | 12 +++++++++--- include/spdlog/details/pattern_formatter_impl.h | 2 +- 4 files changed, 14 insertions(+), 5 deletions(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 86acd362..4508297c 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -60,6 +60,7 @@ class async_log_helper level::level_enum level; log_clock::time_point time; std::string txt; + std::thread::id thread_id; async_msg() = default; ~async_msg() = default; @@ -99,6 +100,7 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT: msg.logger_name = logger_name; msg.level = level; msg.time = time; + msg.thread_id = thread_id; msg.raw << txt; } }; diff --git a/include/spdlog/details/line_logger.h b/include/spdlog/details/line_logger.h index fa616fcf..9afe5f11 100644 --- a/include/spdlog/details/line_logger.h +++ b/include/spdlog/details/line_logger.h @@ -26,7 +26,7 @@ #include #include "../common.h" #include "../logger.h" - +#include // Line logger class - aggregates operator<< calls to fast ostream // and logs upon destruction @@ -65,6 +65,7 @@ public: { _log_msg.logger_name = _callback_logger->name(); _log_msg.time = os::now(); + _log_msg.thread_id = std::this_thread::get_id(); _callback_logger->_log_msg(_log_msg); } } diff --git a/include/spdlog/details/log_msg.h b/include/spdlog/details/log_msg.h index d9fb39b0..5c4bda30 100644 --- a/include/spdlog/details/log_msg.h +++ b/include/spdlog/details/log_msg.h @@ -24,6 +24,7 @@ #pragma once +#include #include "../common.h" #include "./format.h" @@ -38,14 +39,16 @@ struct log_msg logger_name(), level(l), time(), + thread_id(), raw(), formatted() {} log_msg(const log_msg& other) : logger_name(other.logger_name), - level(other.level), - time(other.time) + level(other.level), + time(other.time), + thread_id(other.thread_id) { if (other.raw.size()) raw << fmt::BasicStringRef(other.raw.data(), other.raw.size()); @@ -57,6 +60,7 @@ struct log_msg logger_name(std::move(other.logger_name)), level(other.level), time(std::move(other.time)), + thread_id(other.thread_id), raw(std::move(other.raw)), formatted(std::move(other.formatted)) { @@ -71,6 +75,7 @@ struct log_msg logger_name = std::move(other.logger_name); level = other.level; time = std::move(other.time); + thread_id = other.thread_id; raw = std::move(other.raw); formatted = std::move(other.formatted); other.clear(); @@ -79,7 +84,7 @@ struct log_msg void clear() { - level = level::off; + level = level::off; raw.clear(); formatted.clear(); } @@ -87,6 +92,7 @@ struct log_msg std::string logger_name; level::level_enum level; log_clock::time_point time; + std::thread::id thread_id; fmt::MemoryWriter raw; fmt::MemoryWriter formatted; }; diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index cc9311c5..0bf2ec3a 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -354,7 +354,7 @@ class t_formatter :public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { - msg.formatted << std::hash()(std::this_thread::get_id()); + msg.formatted << std::hash()(msg.thread_id); } }; From 67e0957e6756cdc5fbb203390afa494aea581868 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 7 Apr 2015 20:02:43 +0300 Subject: [PATCH 27/60] Fixed window include bug --- include/spdlog/details/line_logger.h | 1 - 1 file changed, 1 deletion(-) diff --git a/include/spdlog/details/line_logger.h b/include/spdlog/details/line_logger.h index 9afe5f11..d36a251c 100644 --- a/include/spdlog/details/line_logger.h +++ b/include/spdlog/details/line_logger.h @@ -26,7 +26,6 @@ #include #include "../common.h" #include "../logger.h" -#include // Line logger class - aggregates operator<< calls to fast ostream // and logs upon destruction From a09107927b19d7680d8bcb32c076824379604a53 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 7 Apr 2015 20:26:42 +0300 Subject: [PATCH 28/60] Fix Visual Studio poor std::this_thread::get_id() performance by using GetCurrentThreadId() (and pthread_self() under linux) --- include/spdlog/details/async_log_helper.h | 2 +- include/spdlog/details/line_logger.h | 4 +++- include/spdlog/details/log_msg.h | 6 +++--- include/spdlog/details/os.h | 13 +++++++++++++ include/spdlog/details/pattern_formatter_impl.h | 4 ++-- 5 files changed, 22 insertions(+), 7 deletions(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 4508297c..26dcac4b 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -60,7 +60,7 @@ class async_log_helper level::level_enum level; log_clock::time_point time; std::string txt; - std::thread::id thread_id; + uint64_t thread_id; async_msg() = default; ~async_msg() = default; diff --git a/include/spdlog/details/line_logger.h b/include/spdlog/details/line_logger.h index d36a251c..37c7786a 100644 --- a/include/spdlog/details/line_logger.h +++ b/include/spdlog/details/line_logger.h @@ -64,7 +64,9 @@ public: { _log_msg.logger_name = _callback_logger->name(); _log_msg.time = os::now(); - _log_msg.thread_id = std::this_thread::get_id(); + _log_msg.thread_id = os::thread_id(); + + _callback_logger->_log_msg(_log_msg); } } diff --git a/include/spdlog/details/log_msg.h b/include/spdlog/details/log_msg.h index 5c4bda30..34b5ef9a 100644 --- a/include/spdlog/details/log_msg.h +++ b/include/spdlog/details/log_msg.h @@ -46,7 +46,7 @@ struct log_msg log_msg(const log_msg& other) : logger_name(other.logger_name), - level(other.level), + level(other.level), time(other.time), thread_id(other.thread_id) { @@ -84,7 +84,7 @@ struct log_msg void clear() { - level = level::off; + level = level::off; raw.clear(); formatted.clear(); } @@ -92,7 +92,7 @@ struct log_msg std::string logger_name; level::level_enum level; log_clock::time_point time; - std::thread::id thread_id; + uint64_t thread_id; fmt::MemoryWriter raw; fmt::MemoryWriter formatted; }; diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 1fdc27b1..454bd8f5 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -32,6 +32,8 @@ # define WIN32_LEAN_AND_MEAN # endif # include +#else +#include #endif #include "../common.h" @@ -167,6 +169,17 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime()) } +inline uint64_t thread_id() +{ + +#ifdef _WIN32 + return ::GetCurrentThreadId(); +#else + return (uint64_t) pthread_self(); +#endif + +} + } //os } //details } //spdlog diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index 0bf2ec3a..076d76ce 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -354,7 +354,7 @@ class t_formatter :public flag_formatter { void format(details::log_msg& msg, const std::tm&) override { - msg.formatted << std::hash()(msg.thread_id); + msg.formatted << msg.thread_id; } }; @@ -478,7 +478,7 @@ inline void spdlog::pattern_formatter::handle_flag(char flag) { switch (flag) { - // logger name + // logger name case 'n': _formatters.push_back(std::unique_ptr(new details::name_formatter())); break; From 4292d3d9af47483cdefa74151fa5e3861d823d60 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 7 Apr 2015 21:02:34 +0300 Subject: [PATCH 29/60] Use gettid() syscall under linux to get thread id --- include/spdlog/details/os.h | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 454bd8f5..42c62d91 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -32,8 +32,11 @@ # define WIN32_LEAN_AND_MEAN # endif # include +#elif __linux__ +#include //Use gettid() syscall under linux to get thread id +#include #else -#include +#include #endif #include "../common.h" @@ -168,13 +171,15 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime()) #endif } - +//Return current thread id as 64 bit integer inline uint64_t thread_id() { #ifdef _WIN32 return ::GetCurrentThreadId(); -#else +#elif __linux__ + return (uint64_t) syscall(SYS_gettid); +#else return (uint64_t) pthread_self(); #endif From 5067d1c12c7f488134d20575244a9696037b3d6d Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 7 Apr 2015 21:10:43 +0300 Subject: [PATCH 30/60] fixed thread_id bug in async_msg struct --- include/spdlog/details/async_log_helper.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 26dcac4b..9988ff39 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -59,8 +59,8 @@ class async_log_helper std::string logger_name; level::level_enum level; log_clock::time_point time; - std::string txt; uint64_t thread_id; + std::string txt; async_msg() = default; ~async_msg() = default; @@ -77,6 +77,7 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT: logger_name = std::move(other.logger_name); level = other.level; time = std::move(other.time); + thread_id = other.thread_id; txt = std::move(other.txt); return *this; } @@ -89,6 +90,7 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT: logger_name(m.logger_name), level(m.level), time(m.time), + thread_id(m.thread_id), txt(m.raw.data(), m.raw.size()) {} From 7105fdadf937e0ea9e53e23cf85855aa16b69aaf Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 7 Apr 2015 21:16:11 +0300 Subject: [PATCH 31/60] added drop_all() to example --- example/example.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/example/example.cpp b/example/example.cpp index d1ffb297..6159770a 100644 --- a/example/example.cpp +++ b/example/example.cpp @@ -93,7 +93,7 @@ int main(int, char*[]) spdlog::set_async_mode(q_size); auto async_file = spd::daily_logger_st("async_file_logger", "logs/async_log.txt"); async_file->info() << "This is async log.." << "Should be very fast!"; - + spdlog::drop_all(); //Close all loggers // // syslog example. linux only.. // From 0684b4f378eacfd2eccb01e68bed533363b112d9 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 7 Apr 2015 21:35:41 +0300 Subject: [PATCH 32/60] use size_t to better represent thread id across platforms --- include/spdlog/common.h | 1 + include/spdlog/details/async_log_helper.h | 6 +++--- include/spdlog/details/log_msg.h | 2 +- include/spdlog/details/os.h | 8 ++++---- 4 files changed, 9 insertions(+), 8 deletions(-) diff --git a/include/spdlog/common.h b/include/spdlog/common.h index 8a6bfbf2..630f3fab 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -59,6 +59,7 @@ using log_clock = std::chrono::system_clock; using sink_ptr = std::shared_ptr < sinks::sink > ; using sinks_init_list = std::initializer_list < sink_ptr > ; using formatter_ptr = std::shared_ptr; +using thread_id = std::size_t; //Log level enum namespace level diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 9988ff39..e7f6a21f 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -59,7 +59,7 @@ class async_log_helper std::string logger_name; level::level_enum level; log_clock::time_point time; - uint64_t thread_id; + thread_id thread_id; std::string txt; async_msg() = default; @@ -77,7 +77,7 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT: logger_name = std::move(other.logger_name); level = other.level; time = std::move(other.time); - thread_id = other.thread_id; + thread_id = other.thread_id; txt = std::move(other.txt); return *this; } @@ -90,7 +90,7 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT: logger_name(m.logger_name), level(m.level), time(m.time), - thread_id(m.thread_id), + thread_id(m.thread_id), txt(m.raw.data(), m.raw.size()) {} diff --git a/include/spdlog/details/log_msg.h b/include/spdlog/details/log_msg.h index 34b5ef9a..dc72bcda 100644 --- a/include/spdlog/details/log_msg.h +++ b/include/spdlog/details/log_msg.h @@ -92,7 +92,7 @@ struct log_msg std::string logger_name; level::level_enum level; log_clock::time_point time; - uint64_t thread_id; + thread_id thread_id; fmt::MemoryWriter raw; fmt::MemoryWriter formatted; }; diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 42c62d91..5de99085 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -32,11 +32,11 @@ # define WIN32_LEAN_AND_MEAN # endif # include -#elif __linux__ +#elif __linux__ #include //Use gettid() syscall under linux to get thread id #include #else -#include +#include #endif #include "../common.h" @@ -172,14 +172,14 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime()) } //Return current thread id as 64 bit integer -inline uint64_t thread_id() +inline size_t thread_id() { #ifdef _WIN32 return ::GetCurrentThreadId(); #elif __linux__ return (uint64_t) syscall(SYS_gettid); -#else +#else return (uint64_t) pthread_self(); #endif From 25afbd79b2af15b26a3effc1ad8334218be6477e Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 7 Apr 2015 21:57:38 +0300 Subject: [PATCH 33/60] Added compile time option to turn off thread id (#define SPDLOG_NO_THREAD_ID in common.h) --- include/spdlog/common.h | 4 ++++ include/spdlog/details/line_logger.h | 2 -- include/spdlog/details/os.h | 6 +++++- 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/include/spdlog/common.h b/include/spdlog/common.h index 630f3fab..6b494efe 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -44,6 +44,10 @@ //#define SPDLOG_CLOCK_COARSE //#endif + +// uncomment if thread id logging is needed - to gain few nanos +// #define SPDLOG_NO_THREAD_ID +// namespace spdlog { diff --git a/include/spdlog/details/line_logger.h b/include/spdlog/details/line_logger.h index 37c7786a..d037554f 100644 --- a/include/spdlog/details/line_logger.h +++ b/include/spdlog/details/line_logger.h @@ -65,8 +65,6 @@ public: _log_msg.logger_name = _callback_logger->name(); _log_msg.time = os::now(); _log_msg.thread_id = os::thread_id(); - - _callback_logger->_log_msg(_log_msg); } } diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 5de99085..8b073cd4 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -175,6 +175,10 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime()) inline size_t thread_id() { +#ifdef SPDLOG_NO_THREAD_ID + return 0; +#else + #ifdef _WIN32 return ::GetCurrentThreadId(); #elif __linux__ @@ -182,7 +186,7 @@ inline size_t thread_id() #else return (uint64_t) pthread_self(); #endif - +#endif //SPDLOG_NO_THREAD_ID } } //os From 005a36f4fd957a0853c78791895a1bfa5f28dcb9 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 7 Apr 2015 21:58:46 +0300 Subject: [PATCH 34/60] Removed redundant field initializations from log_msg struct --- include/spdlog/details/log_msg.h | 2 -- 1 file changed, 2 deletions(-) diff --git a/include/spdlog/details/log_msg.h b/include/spdlog/details/log_msg.h index dc72bcda..1654cb23 100644 --- a/include/spdlog/details/log_msg.h +++ b/include/spdlog/details/log_msg.h @@ -38,8 +38,6 @@ struct log_msg log_msg(level::level_enum l): logger_name(), level(l), - time(), - thread_id(), raw(), formatted() {} From 4dd31bf031ed38e0ae579bfcf71f447605104054 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 7 Apr 2015 22:04:10 +0300 Subject: [PATCH 35/60] fixed pedantic gcc errors --- include/spdlog/common.h | 2 +- include/spdlog/details/async_log_helper.h | 2 +- include/spdlog/details/log_msg.h | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/include/spdlog/common.h b/include/spdlog/common.h index 6b494efe..ef54a798 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -63,7 +63,7 @@ using log_clock = std::chrono::system_clock; using sink_ptr = std::shared_ptr < sinks::sink > ; using sinks_init_list = std::initializer_list < sink_ptr > ; using formatter_ptr = std::shared_ptr; -using thread_id = std::size_t; +using log_thread_id = std::size_t; //Log level enum namespace level diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index e7f6a21f..ee4c6a01 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -59,7 +59,7 @@ class async_log_helper std::string logger_name; level::level_enum level; log_clock::time_point time; - thread_id thread_id; + log_thread_id thread_id; std::string txt; async_msg() = default; diff --git a/include/spdlog/details/log_msg.h b/include/spdlog/details/log_msg.h index 1654cb23..fd89bd1e 100644 --- a/include/spdlog/details/log_msg.h +++ b/include/spdlog/details/log_msg.h @@ -90,7 +90,7 @@ struct log_msg std::string logger_name; level::level_enum level; log_clock::time_point time; - thread_id thread_id; + log_thread_id thread_id; fmt::MemoryWriter raw; fmt::MemoryWriter formatted; }; From 7cf34ce8204e245f3ede4c5b6bcbf2d8855621eb Mon Sep 17 00:00:00 2001 From: gabime Date: Wed, 8 Apr 2015 10:55:25 +0300 Subject: [PATCH 36/60] Fixed return type in os::get_thread_id --- include/spdlog/details/os.h | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 8b073cd4..e4ad717a 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -171,7 +171,8 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime()) #endif } -//Return current thread id as 64 bit integer +//Return current thread id as size_t +//It exists because the std::this_thread::get_id() is much slower(espcially under VS 2013) inline size_t thread_id() { @@ -182,9 +183,9 @@ inline size_t thread_id() #ifdef _WIN32 return ::GetCurrentThreadId(); #elif __linux__ - return (uint64_t) syscall(SYS_gettid); + return syscall(SYS_gettid); #else - return (uint64_t) pthread_self(); + return pthread_self(); #endif #endif //SPDLOG_NO_THREAD_ID } From 8da33db62f030000b845f053b4f9f141f522a2a2 Mon Sep 17 00:00:00 2001 From: gabime Date: Wed, 8 Apr 2015 10:56:39 +0300 Subject: [PATCH 37/60] Removed redundant "using log_thread_id=size_t" --- include/spdlog/common.h | 2 +- include/spdlog/details/async_log_helper.h | 2 +- include/spdlog/details/log_msg.h | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/include/spdlog/common.h b/include/spdlog/common.h index ef54a798..b420ef82 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -63,7 +63,7 @@ using log_clock = std::chrono::system_clock; using sink_ptr = std::shared_ptr < sinks::sink > ; using sinks_init_list = std::initializer_list < sink_ptr > ; using formatter_ptr = std::shared_ptr; -using log_thread_id = std::size_t; + //Log level enum namespace level diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index ee4c6a01..657c70bb 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -59,7 +59,7 @@ class async_log_helper std::string logger_name; level::level_enum level; log_clock::time_point time; - log_thread_id thread_id; + size_t thread_id; std::string txt; async_msg() = default; diff --git a/include/spdlog/details/log_msg.h b/include/spdlog/details/log_msg.h index fd89bd1e..bf58aca9 100644 --- a/include/spdlog/details/log_msg.h +++ b/include/spdlog/details/log_msg.h @@ -90,7 +90,7 @@ struct log_msg std::string logger_name; level::level_enum level; log_clock::time_point time; - log_thread_id thread_id; + size_t thread_id; fmt::MemoryWriter raw; fmt::MemoryWriter formatted; }; From b715378ff55eb40664d215e9264407b0310ec763 Mon Sep 17 00:00:00 2001 From: gabime Date: Thu, 9 Apr 2015 18:05:16 +0300 Subject: [PATCH 38/60] Added tweakme.h - enable users to enable/disable features at compile time --- include/spdlog/common.h | 11 ---- include/spdlog/details/line_logger.h | 7 ++ include/spdlog/details/os.h | 17 ++--- .../spdlog/details/pattern_formatter_impl.h | 13 +++- include/spdlog/spdlog.h | 17 ++--- include/spdlog/tweakme.h | 66 +++++++++++++++++++ 6 files changed, 97 insertions(+), 34 deletions(-) create mode 100644 include/spdlog/tweakme.h diff --git a/include/spdlog/common.h b/include/spdlog/common.h index b420ef82..cde5a9eb 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -36,18 +36,7 @@ #define SPDLOG_NOEXCEPT throw() #endif -// under linux, you can use the much faster CLOCK_REALTIME_COARSE clock. -// this clock is less accurate - can be off by few millis - depending on the kernel HZ -// uncomment to use it instead of the regular (and slower) clock -//#ifdef __linux__ -//#define SPDLOG_CLOCK_COARSE -//#endif - - -// uncomment if thread id logging is needed - to gain few nanos -// #define SPDLOG_NO_THREAD_ID -// namespace spdlog { diff --git a/include/spdlog/details/line_logger.h b/include/spdlog/details/line_logger.h index d037554f..3a946cb6 100644 --- a/include/spdlog/details/line_logger.h +++ b/include/spdlog/details/line_logger.h @@ -62,9 +62,16 @@ public: { if (_enabled) { +#ifndef SPDLOG_NO_NAME _log_msg.logger_name = _callback_logger->name(); +#endif +#ifndef SPDLOG_NO_DATETIME _log_msg.time = os::now(); +#endif + +#ifndef SPDLOG_NO_THREAD_ID _log_msg.thread_id = os::thread_id(); +#endif _callback_logger->_log_msg(_log_msg); } } diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index e4ad717a..4ba58cbf 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -51,7 +51,7 @@ namespace os inline spdlog::log_clock::time_point now() { -#ifdef SPDLOG_CLOCK_COARSE +#if defined __linux__ && defined SPDLOG_CLOCK_COARSE timespec ts; ::clock_gettime(CLOCK_REALTIME_COARSE, &ts); return std::chrono::time_point( @@ -175,19 +175,14 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime()) //It exists because the std::this_thread::get_id() is much slower(espcially under VS 2013) inline size_t thread_id() { - -#ifdef SPDLOG_NO_THREAD_ID - return 0; -#else - #ifdef _WIN32 - return ::GetCurrentThreadId(); + return static_cast(::GetCurrentThreadId()); #elif __linux__ - return syscall(SYS_gettid); -#else - return pthread_self(); + return static_cast(syscall(SYS_gettid)); +#else //Default to standard C++11 (OSX and other Unix) + return static_cast(std::hash()(std::this_thread::get_id())); #endif -#endif //SPDLOG_NO_THREAD_ID + } } //os diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index 076d76ce..62965364 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -405,6 +405,7 @@ class full_formatter :public flag_formatter { void format(details::log_msg& msg, const std::tm& tm_time) override { +#ifndef SPDLOG_NO_DATETIME auto duration = msg.time.time_since_epoch(); auto millis = std::chrono::duration_cast(duration).count() % 1000; @@ -421,6 +422,7 @@ class full_formatter :public flag_formatter level::to_str(msg.level), msg.raw.str());*/ + // Faster (albeit uglier) way to format the line (5.6 million lines/sec under 10 threads) msg.formatted << '[' << static_cast(tm_time.tm_year + 1900) << '-' << fmt::pad(static_cast(tm_time.tm_mon + 1), 2, '0') << '-' @@ -430,7 +432,16 @@ class full_formatter :public flag_formatter << fmt::pad(static_cast(tm_time.tm_sec), 2, '0') << '.' << fmt::pad(static_cast(millis), 3, '0') << "] "; - msg.formatted << '[' << msg.logger_name << "] [" << level::to_str(msg.level) << "] "; +//no datetime needed +#else + (void)tm_time; +#endif; + +#ifndef SPDLOG_NO_NAME + msg.formatted << '[' << msg.logger_name << "] "; +#endif + + msg.formatted << '[' << level::to_str(msg.level) << "] "; msg.formatted << fmt::StringRef(msg.raw.data(), msg.raw.size()); } }; diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index 85ac8205..73ea63a9 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -28,6 +28,7 @@ #pragma once +#include "tweakme.h" #include "common.h" #include "logger.h" @@ -121,16 +122,17 @@ void drop(const std::string &name); void drop_all(); -// +/////////////////////////////////////////////////////////////////////////////// // // Macros to be display source file & line // Trace & Debug can be switched on/off at compile time for zero cost debug statements. +// Uncomment SPDLOG_DEBUG_ON/SPDLOG_TRACE_ON in teakme.h to enable. // // Example: -// #define SPDLOG_DEBUG_ON -// include "spdlog/spdlog.h" +// spdlog::set_level(spdlog::level::debug); // SPDLOG_DEBUG(my_logger, "Some debug message {} {}", 1, 3.2); -// +/////////////////////////////////////////////////////////////////////////////// + #ifdef SPDLOG_TRACE_ON #define SPDLOG_TRACE(logger, ...) logger->trace(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; #else @@ -143,13 +145,6 @@ void drop_all(); #define SPDLOG_DEBUG(logger, ...) #endif -#define SPDLOG_INFO(logger, ...) logger->info(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; -#define SPDLOG_NOTICE(logger, ...) logger->notice(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; -#define SPDLOG_WARN(logger, ...) logger->warn(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; -#define SPDLOG_ERROR(logger, ...) logger->error(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; -#define SPDLOG_CRITICAL(logger, ...) logger->critical(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; -#define SPDLOG_ALERT(logger, ...) logger->alert(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; -#define SPDLOG_EMERG(logger, ...) logger->emerg(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; } diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h new file mode 100644 index 00000000..427bbd7a --- /dev/null +++ b/include/spdlog/tweakme.h @@ -0,0 +1,66 @@ +/*************************************************************************/ +/* spdlog - an extremely fast and easy to use c++11 logging library. */ +/* Copyright (c) 2014 Gabi Melman. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + + +#pragma once + +/////////////////////////////////////////////////////////////////////////////// +// Edit this file to squeeze every last drop of performance out of spdlog. +/////////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +// Under Linux, the much faster CLOCK_REALTIME_COARSE clock can be used. +// This clock is less accurate - can be off by dozens millis - depending on the kernel HZ +// Uncomment to use it instead of the regular (but slower) clock. +// #define SPDLOG_CLOCK_COARSE +/////////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +// Uncomment if date/time logging is not needed. +// This will prevent spdlog from quering the system clock on each log call. +// #define SPDLOG_NO_DATETIME +/////////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +// Uncomment if thread id logging is not needed (i.e. no %t in the log pattern) +// This will prevent spdlog from quering the thread id on each log call. +// #define SPDLOG_NO_THREAD_ID +/////////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +// Uncomment if logger name logging is not needed. +// This will prevent spdlog from copying the logger name on each log call. +// #define SPDLOG_NO_NAME +/////////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +// Uncomment to enable the SPDLOG_DEBUG/SPDLOG_TRACE macros +// #define SPDLOG_DEBUG_ON +// #define SPDLOG_TRACE_ON +/////////////////////////////////////////////////////////////////////////////// From e8a27a1cee60753eaa43fb4591138fe1f893716d Mon Sep 17 00:00:00 2001 From: gabime Date: Thu, 9 Apr 2015 18:14:39 +0300 Subject: [PATCH 39/60] fixed gcc pedantic warning --- include/spdlog/details/pattern_formatter_impl.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index 62965364..a5b2d21f 100644 --- a/include/spdlog/details/pattern_formatter_impl.h +++ b/include/spdlog/details/pattern_formatter_impl.h @@ -435,7 +435,7 @@ class full_formatter :public flag_formatter //no datetime needed #else (void)tm_time; -#endif; +#endif #ifndef SPDLOG_NO_NAME msg.formatted << '[' << msg.logger_name << "] "; From 3ee728d11b8a52c945ef132d11fafde102956471 Mon Sep 17 00:00:00 2001 From: gabime Date: Thu, 9 Apr 2015 18:20:45 +0300 Subject: [PATCH 40/60] replaced include pthread.h with --- include/spdlog/details/os.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 4ba58cbf..18e3fb71 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -36,7 +36,7 @@ #include //Use gettid() syscall under linux to get thread id #include #else -#include +#include #endif #include "../common.h" From 093c6ee240973364148b2774966614451abf4112 Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Thu, 9 Apr 2015 18:30:02 +0300 Subject: [PATCH 41/60] Update README.md --- README.md | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index e72930b0..2f7e04d3 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@ Just copy the files to your build tree and use a C++11 compiler ## Tested on: * gcc 4.8.1 and above -* clang 3.5 +* clang 3.5 (Linux and OSX) * visual studio 2013 * mingw with g++ 4.9.x @@ -153,5 +153,11 @@ void custom_class_example() spdlog::get("console")->info("custom class with operator<<: {}..", c); spdlog::get("console")->info() << "custom class with operator<<: " << c << ".."; } - ``` + +## Tweaking +spdlog can be tweaked to improve even more performance. + +Edit [this](include/spdlog/tweakme.h) file to disable at compile time un needed features. + + From 2bc634161df0c15088df284183b79df25e59a8d2 Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Thu, 9 Apr 2015 18:30:23 +0300 Subject: [PATCH 42/60] Update README.md --- README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/README.md b/README.md index 2f7e04d3..ac529561 100644 --- a/README.md +++ b/README.md @@ -157,7 +157,6 @@ void custom_class_example() ## Tweaking spdlog can be tweaked to improve even more performance. - Edit [this](include/spdlog/tweakme.h) file to disable at compile time un needed features. From 8b4b5d27ce9b7a787fabb2b72c70cdbc5098e2af Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Thu, 9 Apr 2015 18:32:15 +0300 Subject: [PATCH 43/60] Update README.md --- README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index ac529561..9f5526e8 100644 --- a/README.md +++ b/README.md @@ -156,7 +156,8 @@ void custom_class_example() ``` ## Tweaking -spdlog can be tweaked to improve even more performance. -Edit [this](include/spdlog/tweakme.h) file to disable at compile time un needed features. +spdlog can be tweaked to improve performance even more. + +Edit [this](include/spdlog/tweakme.h) file to disable at compile time unneeded features. From 211ce99d29820f7a02c874360be11978ef40fee8 Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Fri, 10 Apr 2015 12:34:57 +0300 Subject: [PATCH 44/60] Update tweakme.h --- include/spdlog/tweakme.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h index 427bbd7a..20e2c5e4 100644 --- a/include/spdlog/tweakme.h +++ b/include/spdlog/tweakme.h @@ -32,7 +32,7 @@ /////////////////////////////////////////////////////////////////////////////// // Under Linux, the much faster CLOCK_REALTIME_COARSE clock can be used. -// This clock is less accurate - can be off by dozens millis - depending on the kernel HZ +// This clock is less accurate - can be off by dozens of millis - depending on the kernel HZ // Uncomment to use it instead of the regular (but slower) clock. // #define SPDLOG_CLOCK_COARSE /////////////////////////////////////////////////////////////////////////////// @@ -40,7 +40,7 @@ /////////////////////////////////////////////////////////////////////////////// // Uncomment if date/time logging is not needed. -// This will prevent spdlog from quering the system clock on each log call. +// This will prevent spdlog from quering the clock on each log call. // #define SPDLOG_NO_DATETIME /////////////////////////////////////////////////////////////////////////////// From 71341827dcff2e8d53efe918068f689064803f71 Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Sat, 11 Apr 2015 13:14:32 +0300 Subject: [PATCH 45/60] Update README.md --- README.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/README.md b/README.md index 9f5526e8..1a47f299 100644 --- a/README.md +++ b/README.md @@ -156,8 +156,4 @@ void custom_class_example() ``` ## Tweaking -spdlog can be tweaked to improve performance even more. - -Edit [this](include/spdlog/tweakme.h) file to disable at compile time unneeded features. - - +spdlog can be [tweaked](include/spdlog/tweakme.h) to improve performance even more. From 623f59ce6fe72e33c9f6bc2b5c2bcd1ae330d482 Mon Sep 17 00:00:00 2001 From: gabime Date: Sat, 11 Apr 2015 16:36:31 +0300 Subject: [PATCH 46/60] Added register_logger to spdlog.h to register manually created loggers --- include/spdlog/details/registry.h | 11 ++++++++++- include/spdlog/details/spdlog_impl.h | 5 +++++ include/spdlog/spdlog.h | 13 ++++++++----- 3 files changed, 23 insertions(+), 6 deletions(-) diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index 7a283ecd..66536cb4 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -44,6 +44,13 @@ namespace details class registry { public: + + void register_logger(std::shared_ptr logger, const std::string& logger_name) + { + _loggers[logger_name] = logger; + } + + std::shared_ptr get(const std::string& logger_name) { std::lock_guard lock(_mutex); @@ -68,7 +75,8 @@ public: if (_formatter) new_logger->set_formatter(_formatter); new_logger->set_level(_level); - _loggers[logger_name] = new_logger; + register_logger(new_logger, logger_name); + return new_logger; } @@ -93,6 +101,7 @@ public: return create(logger_name, { sink }); } + void formatter(formatter_ptr f) { std::lock_guard lock(_mutex); diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h index 34805597..05e9c7b8 100644 --- a/include/spdlog/details/spdlog_impl.h +++ b/include/spdlog/details/spdlog_impl.h @@ -32,6 +32,11 @@ #include "../sinks/stdout_sinks.h" #include "../sinks/syslog_sink.h" +inline void spdlog::register_logger(std::shared_ptr logger, const std::string& logger_name) +{ + return details::registry::instance().register_logger(logger, logger_name); +} + inline std::shared_ptr spdlog::get(const std::string& name) { return details::registry::instance().get(name); diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index 73ea63a9..d195e1ed 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -74,7 +74,7 @@ void set_async_mode(size_t queue_size, const async_overflow_policy overflow_poli void set_sync_mode(); // -// Create multi/single threaded rotating file logger +// Create and register multi/single threaded rotating file logger // std::shared_ptr rotating_logger_mt(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush = false); std::shared_ptr rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush = false); @@ -87,7 +87,7 @@ std::shared_ptr daily_logger_st(const std::string& logger_name, const st // -// Create stdout/stderr loggers +// Create and register stdout/stderr loggers // std::shared_ptr stdout_logger_mt(const std::string& logger_name); std::shared_ptr stdout_logger_st(const std::string& logger_name); @@ -96,25 +96,28 @@ std::shared_ptr stderr_logger_st(const std::string& logger_name); // -// Create a syslog logger +// Create and register a syslog logger // #ifdef __linux__ std::shared_ptr syslog_logger(const std::string& logger_name, const std::string& ident = "", int syslog_option = 0); #endif -// Create a logger with multiple sinks +// Create and register a logger with multiple sinks std::shared_ptr create(const std::string& logger_name, sinks_init_list sinks); template std::shared_ptr create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end); -// Create a logger with templated sink type +// Create and register a logger with templated sink type // Example: spdlog::create("mylog", "dailylog_filename", "txt"); template std::shared_ptr create(const std::string& logger_name, const Args&...); +// Register the given logger with the given name +void register_logger(std::shared_ptr logger, const std::string& logger_name); + // Drop the reference to the given logger void drop(const std::string &name); From 256c64d72f3c943b16173e59b73615b62f3c1e22 Mon Sep 17 00:00:00 2001 From: gabime Date: Sat, 11 Apr 2015 17:15:20 +0300 Subject: [PATCH 47/60] Fixed registry functions --- include/spdlog/details/registry.h | 26 +++++++++++++++++--------- include/spdlog/details/spdlog_impl.h | 4 ++-- include/spdlog/spdlog.h | 2 +- 3 files changed, 20 insertions(+), 12 deletions(-) diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index 66536cb4..5f708743 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -45,9 +45,10 @@ class registry { public: - void register_logger(std::shared_ptr logger, const std::string& logger_name) + void register_logger(std::shared_ptr logger) { - _loggers[logger_name] = logger; + std::lock_guard lock(_mutex); + register_logger_impl(logger); } @@ -61,12 +62,12 @@ public: template std::shared_ptr create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end) { - std::lock_guard lock(_mutex); - //If already exists, just return it - auto found = _loggers.find(logger_name); - if (found != _loggers.end()) - return found->second; + std::shared_ptr new_logger; + + std::lock_guard lock(_mutex); + + if (_async_mode) new_logger = std::make_shared(logger_name, sinks_begin, sinks_end, _async_q_size, _overflow_policy, _worker_warmup_cb); else @@ -74,9 +75,9 @@ public: if (_formatter) new_logger->set_formatter(_formatter); - new_logger->set_level(_level); - register_logger(new_logger, logger_name); + new_logger->set_level(_level); + register_logger_impl(new_logger); return new_logger; } @@ -148,6 +149,13 @@ public: } private: + void register_logger_impl(std::shared_ptr logger) + { + auto logger_name = logger->name(); + if (_loggers.find(logger_name) != std::end(_loggers)) + throw spdlog_ex("logger with name " + logger_name + " already exists"); + _loggers[logger->name()] = logger; + } registry() = default; registry(const registry&) = delete; registry& operator=(const registry&) = delete; diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h index 05e9c7b8..76843d71 100644 --- a/include/spdlog/details/spdlog_impl.h +++ b/include/spdlog/details/spdlog_impl.h @@ -32,9 +32,9 @@ #include "../sinks/stdout_sinks.h" #include "../sinks/syslog_sink.h" -inline void spdlog::register_logger(std::shared_ptr logger, const std::string& logger_name) +inline void spdlog::register_logger(std::shared_ptr logger) { - return details::registry::instance().register_logger(logger, logger_name); + return details::registry::instance().register_logger(logger); } inline std::shared_ptr spdlog::get(const std::string& name) diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index d195e1ed..8601555f 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -116,7 +116,7 @@ std::shared_ptr create(const std::string& logger_name, const Arg // Register the given logger with the given name -void register_logger(std::shared_ptr logger, const std::string& logger_name); +void register_logger(std::shared_ptr logger); // Drop the reference to the given logger void drop(const std::string &name); From 9c1516859ae324bd2eb2e5e29c3313b774344306 Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Sat, 11 Apr 2015 18:35:39 +0300 Subject: [PATCH 48/60] Update README.md --- README.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.md b/README.md index 1a47f299..e14a5160 100644 --- a/README.md +++ b/README.md @@ -157,3 +157,7 @@ void custom_class_example() ## Tweaking spdlog can be [tweaked](include/spdlog/tweakme.h) to improve performance even more. + +## Documentation +Can be found in the [wiki](wiki) pages. + From 0e75381b18a398691601a092cc073a811ed5843f Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Sat, 11 Apr 2015 18:36:44 +0300 Subject: [PATCH 49/60] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index e14a5160..2d01832e 100644 --- a/README.md +++ b/README.md @@ -159,5 +159,5 @@ void custom_class_example() spdlog can be [tweaked](include/spdlog/tweakme.h) to improve performance even more. ## Documentation -Can be found in the [wiki](wiki) pages. +Can be found in the [wiki](https://github.com/gabime/spdlog/wiki) pages. From 7ec1c2ea5413d062538f282953b0c64bc43662cd Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Sat, 11 Apr 2015 18:40:51 +0300 Subject: [PATCH 50/60] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 2d01832e..fe881d60 100644 --- a/README.md +++ b/README.md @@ -159,5 +159,5 @@ void custom_class_example() spdlog can be [tweaked](include/spdlog/tweakme.h) to improve performance even more. ## Documentation -Can be found in the [wiki](https://github.com/gabime/spdlog/wiki) pages. +Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages. From 1a8f7ccf51fa39847df7bd9a771e87a38f15576d Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Sat, 11 Apr 2015 18:46:05 +0300 Subject: [PATCH 51/60] Update README.md --- README.md | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index fe881d60..aebce7fe 100644 --- a/README.md +++ b/README.md @@ -5,17 +5,21 @@ Very fast, header only, C++ logging library. ## Install Just copy the files to your build tree and use a C++11 compiler -## Tested on: +## Supported Platforms + * Linux (32/64 bits) + * Windows (32/64 bits) + * MAC OSX + +## Supported Compilers: * gcc 4.8.1 and above -* clang 3.5 (Linux and OSX) -* visual studio 2013 -* mingw with g++ 4.9.x +* clang 3.5 and above +* visual studio 2013 and above +* mingw with g++ 4.9.x and above ##Features * Very fast - performance is the primary goal (see [benchmarks](#benchmarks) below). * Headers only. * No dependencies - just copy and use. -* Cross platform - Linux / Windows on 32/64 bits. * **new!** Feature rich [call style](#usage-example) using the excellent [cppformat](http://cppformat.github.io/) library. * ostream call style is supported too. * Extremely fast asynchronous mode (optional) - using lockfree queues and other tricks to reach millions of calls/sec. From fb6fa127620484246f5883868748e001bda9a1b5 Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Sat, 11 Apr 2015 18:49:20 +0300 Subject: [PATCH 52/60] Update README.md --- README.md | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index aebce7fe..c84eafa1 100644 --- a/README.md +++ b/README.md @@ -5,17 +5,11 @@ Very fast, header only, C++ logging library. ## Install Just copy the files to your build tree and use a C++11 compiler -## Supported Platforms - * Linux (32/64 bits) - * Windows (32/64 bits) - * MAC OSX +## Platforms + * Linux (gcc 4.8.1+, clang 3.5+) + * Windows (visual studio 2013+, mingw with g++ 4.9.1+) + * MAC OSX (clang 3.5+) -## Supported Compilers: -* gcc 4.8.1 and above -* clang 3.5 and above -* visual studio 2013 and above -* mingw with g++ 4.9.x and above - ##Features * Very fast - performance is the primary goal (see [benchmarks](#benchmarks) below). * Headers only. From b7fcc44108e6ad94a6a4933141a1bd36be383be3 Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Sat, 11 Apr 2015 18:50:36 +0300 Subject: [PATCH 53/60] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index c84eafa1..0c1aa69e 100644 --- a/README.md +++ b/README.md @@ -8,7 +8,7 @@ Just copy the files to your build tree and use a C++11 compiler ## Platforms * Linux (gcc 4.8.1+, clang 3.5+) * Windows (visual studio 2013+, mingw with g++ 4.9.1+) - * MAC OSX (clang 3.5+) + * Mac OSX (clang 3.5+) ##Features * Very fast - performance is the primary goal (see [benchmarks](#benchmarks) below). From 39b0bfa3eb82fdb4bc0ec4c7d3db7577eeb4ee01 Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Sat, 11 Apr 2015 18:51:50 +0300 Subject: [PATCH 54/60] Update README.md --- README.md | 3 --- 1 file changed, 3 deletions(-) diff --git a/README.md b/README.md index 0c1aa69e..3a59382a 100644 --- a/README.md +++ b/README.md @@ -153,9 +153,6 @@ void custom_class_example() } ``` -## Tweaking -spdlog can be [tweaked](include/spdlog/tweakme.h) to improve performance even more. - ## Documentation Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages. From 23ec6336639923e68f3c4b513901990e12251fce Mon Sep 17 00:00:00 2001 From: Gabi Melman Date: Sat, 11 Apr 2015 18:54:24 +0300 Subject: [PATCH 55/60] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 3a59382a..7db15533 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ Just copy the files to your build tree and use a C++11 compiler * Very fast - performance is the primary goal (see [benchmarks](#benchmarks) below). * Headers only. * No dependencies - just copy and use. -* **new!** Feature rich [call style](#usage-example) using the excellent [cppformat](http://cppformat.github.io/) library. +* Feature rich [call style](#usage-example) using the excellent [cppformat](http://cppformat.github.io/) library. * ostream call style is supported too. * Extremely fast asynchronous mode (optional) - using lockfree queues and other tricks to reach millions of calls/sec. * [Custom](https://github.com/gabime/spdlog/wiki/Custom-formatting) formatting. From 2a0d00929cb6795bdf2c7a81ae7d5ec55bbb3662 Mon Sep 17 00:00:00 2001 From: gabime Date: Sat, 18 Apr 2015 01:47:30 +0300 Subject: [PATCH 56/60] stdout_loggers now thread safe across all instances (share same stdout_sink_mt) --- include/spdlog/details/spdlog_impl.h | 8 ++++---- include/spdlog/sinks/stdout_sinks.h | 14 +++++++++++++- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h index 76843d71..5e1bc73a 100644 --- a/include/spdlog/details/spdlog_impl.h +++ b/include/spdlog/details/spdlog_impl.h @@ -72,22 +72,22 @@ inline std::shared_ptr spdlog::daily_logger_st(const std::string // Create stdout/stderr loggers inline std::shared_ptr spdlog::stdout_logger_mt(const std::string& logger_name) { - return create(logger_name); + return details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_mt::instance()); } inline std::shared_ptr spdlog::stdout_logger_st(const std::string& logger_name) { - return create(logger_name); + return details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_st::instance()); } inline std::shared_ptr spdlog::stderr_logger_mt(const std::string& logger_name) { - return create(logger_name); + return details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_mt::instance()); } inline std::shared_ptr spdlog::stderr_logger_st(const std::string& logger_name) { - return create(logger_name); + return details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_st::instance()); } #ifdef __linux__ diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h index e944e273..5ad06c29 100644 --- a/include/spdlog/sinks/stdout_sinks.h +++ b/include/spdlog/sinks/stdout_sinks.h @@ -37,9 +37,14 @@ namespace sinks template class stdout_sink : public ostream_sink { + using MyType = stdout_sink; public: stdout_sink() : ostream_sink(std::cout, true) {} - + static std::shared_ptr instance() + { + static std::shared_ptr instance = std::make_shared(); + return instance; + } }; typedef stdout_sink stdout_sink_st; @@ -49,8 +54,15 @@ typedef stdout_sink stdout_sink_mt; template class stderr_sink : public ostream_sink { + using MyType = stderr_sink; public: stderr_sink() : ostream_sink(std::cerr, true) {} + static std::shared_ptr instance() + { + static std::shared_ptr instance = std::make_shared(); + return instance; + } + }; typedef stderr_sink stderr_sink_mt; From 2269f4d9f8b1d4e6a46f684e76a98528f6938585 Mon Sep 17 00:00:00 2001 From: gabime Date: Sun, 26 Apr 2015 23:38:43 +0300 Subject: [PATCH 57/60] Fixed bug #81 (Doesn't compile on OS X under gcc-4.9 ) --- include/spdlog/details/format.cc | 1624 ++++++------- include/spdlog/details/format.h | 3657 ++++++++++++++---------------- 2 files changed, 2535 insertions(+), 2746 deletions(-) diff --git a/include/spdlog/details/format.cc b/include/spdlog/details/format.cc index 0b7b5742..4de135cf 100644 --- a/include/spdlog/details/format.cc +++ b/include/spdlog/details/format.cc @@ -1,29 +1,29 @@ /* -Formatting library for C++ + Formatting library for C++ -Copyright (c) 2012 - 2014, Victor Zverovich -All rights reserved. + Copyright (c) 2012 - 2015, Victor Zverovich + All rights reserved. -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: -1. Redistributions of source code must retain the above copyright notice, this -list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, -this list of conditions and the following disclaimer in the documentation -and/or other materials provided with the distribution. + 1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ #include "format.h" @@ -66,10 +66,8 @@ using fmt::internal::Arg; #ifndef FMT_THROW # if FMT_EXCEPTIONS # define FMT_THROW(x) throw x -# define FMT_RETURN_AFTER_THROW(x) # else # define FMT_THROW(x) assert(false) -# define FMT_RETURN_AFTER_THROW(x) return x # endif #endif @@ -83,45 +81,63 @@ using fmt::internal::Arg; # pragma warning(push) # pragma warning(disable: 4127) // conditional expression is constant # pragma warning(disable: 4702) // unreachable code +// Disable deprecation warning for strerror. The latter is not called but +// MSVC fails to detect it. +# pragma warning(disable: 4996) #endif +// Dummy implementations of strerror_r and strerror_s called if corresponding +// system functions are not available. +static inline fmt::internal::None<> strerror_r(int, char *, ...) { + return fmt::internal::None<>(); +} +static inline fmt::internal::None<> strerror_s(char *, std::size_t, ...) { + return fmt::internal::None<>(); +} + namespace { #ifndef _MSC_VER # define FMT_SNPRINTF snprintf #else // _MSC_VER inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) { - va_list args; - va_start(args, format); - int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args); - va_end(args); - return result; + va_list args; + va_start(args, format); + int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args); + va_end(args); + return result; } # define FMT_SNPRINTF fmt_snprintf #endif // _MSC_VER +#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) +# define FMT_SWPRINTF snwprintf +#else +# define FMT_SWPRINTF swprintf +#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) + // Checks if a value fits in int - used to avoid warnings about comparing // signed and unsigned integers. template struct IntChecker { - template - static bool fits_in_int(T value) { - unsigned max = INT_MAX; - return value <= max; - } + template + static bool fits_in_int(T value) { + unsigned max = INT_MAX; + return value <= max; + } }; template <> struct IntChecker { - template - static bool fits_in_int(T value) { - return value >= INT_MIN && value <= INT_MAX; - } + template + static bool fits_in_int(T value) { + return value >= INT_MIN && value <= INT_MAX; + } }; const char RESET_COLOR[] = "\x1b[0m"; -typedef void(*FormatFunc)(fmt::Writer &, int, fmt::StringRef); +typedef void (*FormatFunc)(fmt::Writer &, int, fmt::StringRef); // Portable thread-safe version of strerror. // Sets buffer to point to a string describing the error code. @@ -133,220 +149,235 @@ typedef void(*FormatFunc)(fmt::Writer &, int, fmt::StringRef); // other - failure // Buffer should be at least of size 1. int safe_strerror( - int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT{ - assert(buffer != 0 && buffer_size != 0); - int result = 0; -#if ((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && !_GNU_SOURCE) || __ANDROID__ - // XSI-compliant version of strerror_r. - result = strerror_r(error_code, buffer, buffer_size); - if (result != 0) - result = errno; -#elif _GNU_SOURCE - // GNU-specific version of strerror_r. - char *message = strerror_r(error_code, buffer, buffer_size); - // If the buffer is full then the message is probably truncated. - if (message == buffer && strlen(buffer) == buffer_size - 1) - result = ERANGE; - buffer = message; -#elif __MINGW32__ - errno = 0; - (void)buffer_size; - buffer = strerror(error_code); - result = errno; -#elif _WIN32 - result = strerror_s(buffer, buffer_size, error_code); - // If the buffer is full then the message is probably truncated. - if (result == 0 && std::strlen(buffer) == buffer_size - 1) - result = ERANGE; -#else - result = strerror_r(error_code, buffer, buffer_size); - if (result == -1) - result = errno; // glibc versions before 2.13 return result in errno. -#endif - return result; + int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT { + assert(buffer != 0 && buffer_size != 0); + + 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::None<>) { + 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::None<>) { + errno = 0; + buffer_ = strerror(error_code_); + return errno; + } + + public: + StrError(int error_code, char *&buffer, std::size_t buffer_size) + : error_code_(error_code), buffer_(buffer), buffer_size_(buffer_size) {} + + int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); } + }; + return StrError(error_code, buffer, buffer_size).run(); } void format_error_code(fmt::Writer &out, int error_code, - 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 ERR[] = "error "; - fmt::internal::IntTraits::MainType ec_value = error_code; - // Subtract 2 to account for terminating null characters in SEP and ERR. - std::size_t error_code_size = - sizeof(SEP) + sizeof(ERR) + fmt::internal::count_digits(ec_value) - 2; - if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size) - out << message << SEP; - out << ERR << error_code; - assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE); + 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::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); } void report_error(FormatFunc func, - 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); + 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); } // IsZeroInt::visit(arg) returns true iff arg is a zero integer. class IsZeroInt : public fmt::internal::ArgVisitor { -public: - template - bool visit_any_int(T value) { - return value == 0; - } + public: + template + bool visit_any_int(T value) { return value == 0; } }; // Parses an unsigned integer advancing s to the end of the parsed input. // This function assumes that the first character of s is a digit. template int parse_nonnegative_int(const Char *&s) { - 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; + 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; } inline void require_numeric_argument(const Arg &arg, char spec) { - if (arg.type > Arg::LAST_NUMERIC_TYPE) { - std::string message = - fmt::format("format specifier '{}' requires numeric argument", spec); - FMT_THROW(fmt::FormatError(message)); - } + if (arg.type > Arg::LAST_NUMERIC_TYPE) { + std::string message = + fmt::format("format specifier '{}' requires numeric argument", spec); + FMT_THROW(fmt::FormatError(message)); + } } template void check_sign(const Char *&s, const Arg &arg) { - char sign = static_cast(*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; + char sign = static_cast(*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; } // Checks if an argument is a valid printf width specifier and sets // left alignment if it is negative. class WidthHandler : public fmt::internal::ArgVisitor { -private: - fmt::FormatSpec &spec_; + private: + fmt::FormatSpec &spec_; - FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler); + FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler); -public: - explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {} + public: + explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {} - unsigned visit_unhandled_arg() { - FMT_THROW(fmt::FormatError("width is not integer")); - FMT_RETURN_AFTER_THROW(0); - } - - template - unsigned visit_any_int(T value) { - typedef typename fmt::internal::IntTraits::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(width); + void report_unhandled_arg() { + FMT_THROW(fmt::FormatError("width is not integer")); + } + + template + unsigned visit_any_int(T value) { + typedef typename fmt::internal::IntTraits::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(width); + } }; class PrecisionHandler : public fmt::internal::ArgVisitor { -public: - unsigned visit_unhandled_arg() { - FMT_THROW(fmt::FormatError("precision is not integer")); - FMT_RETURN_AFTER_THROW(0); - } + public: + void report_unhandled_arg() { + FMT_THROW(fmt::FormatError("precision is not integer")); + } - template - int visit_any_int(T value) { - if (!IntChecker::is_signed>::fits_in_int(value)) - FMT_THROW(fmt::FormatError("number is too big")); - return static_cast(value); - } + template + int visit_any_int(T value) { + if (!IntChecker::is_signed>::fits_in_int(value)) + FMT_THROW(fmt::FormatError("number is too big")); + return static_cast(value); + } }; // Converts an integer argument to an integral type T for printf. template class ArgConverter : public fmt::internal::ArgVisitor, void> { -private: - fmt::internal::Arg &arg_; - wchar_t type_; + private: + fmt::internal::Arg &arg_; + wchar_t type_; - FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter); + FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter); -public: - ArgConverter(fmt::internal::Arg &arg, wchar_t type) - : arg_(arg), type_(type) {} + public: + ArgConverter(fmt::internal::Arg &arg, wchar_t type) + : arg_(arg), type_(type) {} - template - 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(static_cast(value)); - } - else { - arg_.type = Arg::UINT; - arg_.uint_value = static_cast( - static_cast::Type>(value)); - } - } - else { - if (is_signed) { - arg_.type = Arg::LONG_LONG; - arg_.long_long_value = - static_cast::Type>(value); - } - else { - arg_.type = Arg::ULONG_LONG; - arg_.ulong_long_value = - static_cast::Type>(value); - } - } + template + 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(static_cast(value)); + } else { + arg_.type = Arg::UINT; + arg_.uint_value = static_cast( + static_cast::Type>(value)); + } + } else { + if (is_signed) { + arg_.type = Arg::LONG_LONG; + arg_.long_long_value = + static_cast::Type>(value); + } else { + arg_.type = Arg::ULONG_LONG; + arg_.ulong_long_value = + static_cast::Type>(value); + } } + } }; // Converts an integer argument to char for printf. class CharConverter : public fmt::internal::ArgVisitor { -private: - fmt::internal::Arg &arg_; + private: + fmt::internal::Arg &arg_; - FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter); + FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter); -public: - explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {} + public: + explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {} - template - void visit_any_int(T value) { - arg_.type = Arg::CHAR; - arg_.int_value = static_cast(value); - } + template + void visit_any_int(T value) { + arg_.type = Arg::CHAR; + arg_.int_value = static_cast(value); + } }; // This function template is used to prevent compile errors when handling @@ -357,52 +388,48 @@ Arg::StringValue ignore_incompatible_str(Arg::StringValue); template <> inline Arg::StringValue ignore_incompatible_str( - Arg::StringValue) { - return Arg::StringValue(); -} + Arg::StringValue) { return Arg::StringValue(); } template <> inline Arg::StringValue ignore_incompatible_str( - Arg::StringValue s) { - return s; -} + Arg::StringValue s) { return s; } } // namespace FMT_FUNC void fmt::SystemError::init( int err_code, StringRef format_str, ArgList args) { - error_code_ = err_code; - MemoryWriter w; - internal::format_system_error(w, err_code, format(format_str, args)); - std::runtime_error &base = *this; - base = std::runtime_error(w.str()); + error_code_ = err_code; + MemoryWriter w; + internal::format_system_error(w, err_code, format(format_str, args)); + std::runtime_error &base = *this; + base = std::runtime_error(w.str()); } template int fmt::internal::CharTraits::format_float( char *buffer, std::size_t size, const char *format, unsigned width, int precision, T value) { - if (width == 0) { - return precision < 0 ? - FMT_SNPRINTF(buffer, size, format, value) : - FMT_SNPRINTF(buffer, size, format, precision, value); - } + if (width == 0) { return precision < 0 ? - FMT_SNPRINTF(buffer, size, format, width, value) : - FMT_SNPRINTF(buffer, size, format, width, precision, value); + FMT_SNPRINTF(buffer, size, format, value) : + FMT_SNPRINTF(buffer, size, format, precision, value); + } + return precision < 0 ? + FMT_SNPRINTF(buffer, size, format, width, value) : + FMT_SNPRINTF(buffer, size, format, width, precision, value); } template int fmt::internal::CharTraits::format_float( wchar_t *buffer, std::size_t size, const wchar_t *format, unsigned width, int precision, T value) { - if (width == 0) { - return precision < 0 ? - swprintf(buffer, size, format, value) : - swprintf(buffer, size, format, precision, value); - } + if (width == 0) { return precision < 0 ? - swprintf(buffer, size, format, width, value) : - swprintf(buffer, size, format, width, precision, value); + FMT_SWPRINTF(buffer, size, format, value) : + FMT_SWPRINTF(buffer, size, format, precision, value); + } + return precision < 0 ? + FMT_SWPRINTF(buffer, size, format, width, value) : + FMT_SWPRINTF(buffer, size, format, width, precision, value); } template @@ -426,127 +453,124 @@ const char fmt::internal::BasicData::DIGITS[] = template const uint32_t fmt::internal::BasicData::POWERS_OF_10_32[] = { - 0, FMT_POWERS_OF_10(1) + 0, FMT_POWERS_OF_10(1) }; template const uint64_t fmt::internal::BasicData::POWERS_OF_10_64[] = { - 0, - FMT_POWERS_OF_10(1), - FMT_POWERS_OF_10(fmt::ULongLong(1000000000)), - // Multiply several constants instead of using a single long long constant - // to avoid warnings about C++98 not supporting long long. - fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10 + 0, + FMT_POWERS_OF_10(1), + FMT_POWERS_OF_10(fmt::ULongLong(1000000000)), + // Multiply several constants instead of using a single long long constant + // to avoid warnings about C++98 not supporting long long. + fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10 }; FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type) { - if (std::isprint(static_cast(code))) { - FMT_THROW(fmt::FormatError( - fmt::format("unknown format code '{}' for {}", code, type))); - } + (void)type; + if (std::isprint(static_cast(code))) { FMT_THROW(fmt::FormatError( - fmt::format("unknown format code '\\x{:02x}' for {}", - static_cast(code), type))); + fmt::format("unknown format code '{}' for {}", code, type))); + } + FMT_THROW(fmt::FormatError( + fmt::format("unknown format code '\\x{:02x}' for {}", + static_cast(code), type))); } #ifdef _WIN32 FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) { - int length = MultiByteToWideChar( - CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), -1, 0, 0); - static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16"; - if (length == 0) - FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); - buffer_.resize(length); - length = MultiByteToWideChar( - CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), -1, &buffer_[0], length); - if (length == 0) - FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); + int length = MultiByteToWideChar( + CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), -1, 0, 0); + static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16"; + if (length == 0) + FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); + buffer_.resize(length); + length = MultiByteToWideChar( + CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), -1, &buffer_[0], length); + if (length == 0) + FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); } FMT_FUNC fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s) { - if (int error_code = convert(s)) { - FMT_THROW(WindowsError(error_code, - "cannot convert string from UTF-16 to UTF-8")); - } + if (int error_code = convert(s)) { + FMT_THROW(WindowsError(error_code, + "cannot convert string from UTF-16 to UTF-8")); + } } FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) { - int length = WideCharToMultiByte(CP_UTF8, 0, s.c_str(), -1, 0, 0, 0, 0); - if (length == 0) - return GetLastError(); - buffer_.resize(length); - length = WideCharToMultiByte( - CP_UTF8, 0, s.c_str(), -1, &buffer_[0], length, 0, 0); - if (length == 0) - return GetLastError(); - return 0; + int length = WideCharToMultiByte(CP_UTF8, 0, s.c_str(), -1, 0, 0, 0, 0); + if (length == 0) + return GetLastError(); + buffer_.resize(length); + length = WideCharToMultiByte( + CP_UTF8, 0, s.c_str(), -1, &buffer_[0], length, 0, 0); + if (length == 0) + return GetLastError(); + return 0; } FMT_FUNC void fmt::WindowsError::init( int err_code, StringRef format_str, ArgList args) { - error_code_ = err_code; - MemoryWriter w; - internal::format_windows_error(w, err_code, format(format_str, args)); - std::runtime_error &base = *this; - base = std::runtime_error(w.str()); + error_code_ = err_code; + MemoryWriter w; + internal::format_windows_error(w, err_code, format(format_str, args)); + std::runtime_error &base = *this; + base = std::runtime_error(w.str()); } #endif FMT_FUNC void fmt::internal::format_system_error( fmt::Writer &out, int error_code, - fmt::StringRef message) FMT_NOEXCEPT{ - FMT_TRY{ - MemoryBuffer buffer; - buffer.resize(INLINE_BUFFER_SIZE); - for (;;) { - char *system_message = &buffer[0]; - int result = safe_strerror(error_code, system_message, buffer.size()); - if (result == 0) { - out << message << ": " << system_message; - return; - } - if (result != ERANGE) - break; // Can't get error message, report error code instead. - buffer.resize(buffer.size() * 2); - } - } FMT_CATCH(...) {} - format_error_code(out, error_code, message); + fmt::StringRef message) FMT_NOEXCEPT { + FMT_TRY { + MemoryBuffer buffer; + buffer.resize(INLINE_BUFFER_SIZE); + for (;;) { + char *system_message = &buffer[0]; + int result = safe_strerror(error_code, system_message, buffer.size()); + if (result == 0) { + out << message << ": " << system_message; + return; + } + if (result != ERANGE) + break; // Can't get error message, report error code instead. + buffer.resize(buffer.size() * 2); + } + } FMT_CATCH(...) {} + format_error_code(out, error_code, message); } #ifdef _WIN32 FMT_FUNC void fmt::internal::format_windows_error( fmt::Writer &out, int error_code, - fmt::StringRef message) FMT_NOEXCEPT{ - class String { - private: - LPWSTR str_; + fmt::StringRef message) FMT_NOEXCEPT { + class String { + private: + LPWSTR str_; - public: - String() : str_() {} - ~String() { - LocalFree(str_); - } - LPWSTR *ptr() { - return &str_; - } - LPCWSTR c_str() const { return str_; } - }; - FMT_TRY{ - String system_message; - if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | + public: + String() : str_() {} + ~String() { LocalFree(str_); } + LPWSTR *ptr() { return &str_; } + LPCWSTR c_str() const { return str_; } + }; + FMT_TRY { + String system_message; + if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), reinterpret_cast(system_message.ptr()), 0, 0)) { - UTF16ToUTF8 utf8_message; - if (utf8_message.convert(system_message.c_str()) == ERROR_SUCCESS) { - out << message << ": " << utf8_message; - return; - } - } - } FMT_CATCH(...) {} - format_error_code(out, error_code, message); + UTF16ToUTF8 utf8_message; + if (utf8_message.convert(system_message.c_str()) == ERROR_SUCCESS) { + out << message << ": " << utf8_message; + return; + } + } + } FMT_CATCH(...) {} + format_error_code(out, error_code, message); } #endif @@ -554,603 +578,597 @@ FMT_FUNC void fmt::internal::format_windows_error( template class fmt::internal::ArgFormatter : public fmt::internal::ArgVisitor, void> { -private: - fmt::BasicFormatter &formatter_; - fmt::BasicWriter &writer_; - fmt::FormatSpec &spec_; - const Char *format_; + private: + fmt::BasicFormatter &formatter_; + fmt::BasicWriter &writer_; + fmt::FormatSpec &spec_; + const Char *format_; - FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatter); + FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatter); -public: - ArgFormatter( - fmt::BasicFormatter &f, fmt::FormatSpec &s, const Char *fmt) - : formatter_(f), writer_(f.writer()), spec_(s), format_(fmt) {} + public: + ArgFormatter( + fmt::BasicFormatter &f,fmt::FormatSpec &s, const Char *fmt) + : formatter_(f), writer_(f.writer()), spec_(s), format_(fmt) {} - template - void visit_any_int(T value) { - writer_.write_int(value, spec_); + template + void visit_any_int(T value) { writer_.write_int(value, spec_); } + + template + void visit_any_double(T value) { writer_.write_double(value, spec_); } + + 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 fmt::BasicWriter::CharPtr CharPtr; + Char fill = static_cast(spec_.fill()); + if (spec_.precision_ == 0) { + std::fill_n(writer_.grow_buffer(spec_.width_), spec_.width_, fill); + return; + } + CharPtr out = CharPtr(); + if (spec_.width_ > 1) { + out = writer_.grow_buffer(spec_.width_); + if (spec_.align_ == fmt::ALIGN_RIGHT) { + std::fill_n(out, spec_.width_ - 1, fill); + out += spec_.width_ - 1; + } else if (spec_.align_ == fmt::ALIGN_CENTER) { + out = writer_.fill_padding(out, spec_.width_, 1, fill); + } else { + std::fill_n(out + 1, spec_.width_ - 1, fill); + } + } else { + out = writer_.grow_buffer(1); + } + *out = static_cast(value); + } - template - void visit_any_double(T value) { - writer_.write_double(value, spec_); - } + void visit_string(Arg::StringValue value) { + writer_.write_str(value, spec_); + } + void visit_wstring(Arg::StringValue value) { + writer_.write_str(ignore_incompatible_str(value), spec_); + } - 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 fmt::BasicWriter::CharPtr CharPtr; - Char fill = static_cast(spec_.fill()); - if (spec_.precision_ == 0) { - std::fill_n(writer_.grow_buffer(spec_.width_), spec_.width_, fill); - return; - } - CharPtr out = CharPtr(); - if (spec_.width_ > 1) { - out = writer_.grow_buffer(spec_.width_); - if (spec_.align_ == fmt::ALIGN_RIGHT) { - std::fill_n(out, spec_.width_ - 1, fill); - out += spec_.width_ - 1; - } - else if (spec_.align_ == fmt::ALIGN_CENTER) { - out = writer_.fill_padding(out, spec_.width_, 1, fill); - } - else { - std::fill_n(out + 1, spec_.width_ - 1, fill); - } - } - else { - out = writer_.grow_buffer(1); - } - *out = static_cast(value); - } + void visit_pointer(const void *value) { + if (spec_.type_ && spec_.type_ != 'p') + fmt::internal::report_unknown_type(spec_.type_, "pointer"); + spec_.flags_ = fmt::HASH_FLAG; + spec_.type_ = 'x'; + writer_.write_int(reinterpret_cast(value), spec_); + } - void visit_string(Arg::StringValue value) { - writer_.write_str(value, spec_); - } - void visit_wstring(Arg::StringValue value) { - writer_.write_str(ignore_incompatible_str(value), spec_); - } - - void visit_pointer(const void *value) { - if (spec_.type_ && spec_.type_ != 'p') - fmt::internal::report_unknown_type(spec_.type_, "pointer"); - spec_.flags_ = fmt::HASH_FLAG; - spec_.type_ = 'x'; - writer_.write_int(reinterpret_cast(value), spec_); - } - - void visit_custom(Arg::CustomValue c) { - c.format(&formatter_, c.value, &format_); - } + void visit_custom(Arg::CustomValue c) { + c.format(&formatter_, c.value, &format_); + } }; +template +void fmt::internal::FixedBuffer::grow(std::size_t) { + FMT_THROW(std::runtime_error("buffer overflow")); +} + template template void fmt::BasicWriter::write_str( const Arg::StringValue &s, const FormatSpec &spec) { - // Check if StrChar is convertible to Char. - internal::CharTraits::convert(StrChar()); - if (spec.type_ && spec.type_ != 's') - internal::report_unknown_type(spec.type_, "string"); - const StrChar *str_value = s.value; - std::size_t str_size = s.size; - if (str_size == 0) { - if (!str_value) - FMT_THROW(FormatError("string pointer is null")); - if (*str_value) - str_size = std::char_traits::length(str_value); - } - std::size_t precision = spec.precision_; - if (spec.precision_ >= 0 && precision < str_size) - str_size = spec.precision_; - write_str(str_value, str_size, spec); + // Check if StrChar is convertible to Char. + internal::CharTraits::convert(StrChar()); + if (spec.type_ && spec.type_ != 's') + internal::report_unknown_type(spec.type_, "string"); + const StrChar *str_value = s.value; + std::size_t str_size = s.size; + if (str_size == 0) { + if (!str_value) + FMT_THROW(FormatError("string pointer is null")); + if (*str_value) + str_size = std::char_traits::length(str_value); + } + std::size_t precision = spec.precision_; + if (spec.precision_ >= 0 && precision < str_size) + str_size = spec.precision_; + write_str(str_value, str_size, spec); } template inline Arg fmt::BasicFormatter::parse_arg_index(const Char *&s) { - const char *error = 0; - Arg arg = *s < '0' || *s > '9' ? - next_arg(error) : get_arg(parse_nonnegative_int(s), error); - if (error) { - FMT_THROW(FormatError( - *s != '}' && *s != ':' ? "invalid format string" : error)); - } - return arg; + const char *error = 0; + Arg arg = *s < '0' || *s > '9' ? + next_arg(error) : get_arg(parse_nonnegative_int(s), error); + if (error) { + FMT_THROW(FormatError( + *s != '}' && *s != ':' ? "invalid format string" : error)); + } + return arg; } FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg( unsigned arg_index, const char *&error) { - Arg arg = args_[arg_index]; - if (arg.type == Arg::NONE) - error = "argument index out of range"; - return arg; + Arg arg = args_[arg_index]; + if (arg.type == Arg::NONE) + error = "argument index out of range"; + return arg; } inline Arg fmt::internal::FormatterBase::next_arg(const char *&error) { - if (next_arg_index_ >= 0) - return do_get_arg(next_arg_index_++, error); - error = "cannot switch from manual to automatic argument indexing"; - return Arg(); + if (next_arg_index_ >= 0) + return do_get_arg(next_arg_index_++, error); + error = "cannot switch from manual to automatic argument indexing"; + return Arg(); } inline Arg fmt::internal::FormatterBase::get_arg( unsigned arg_index, const char *&error) { - if (next_arg_index_ <= 0) { - next_arg_index_ = -1; - return do_get_arg(arg_index, error); - } - error = "cannot switch from automatic to manual argument indexing"; - return Arg(); + if (next_arg_index_ <= 0) { + next_arg_index_ = -1; + return do_get_arg(arg_index, error); + } + error = "cannot switch from automatic to manual argument indexing"; + return Arg(); } template void fmt::internal::PrintfFormatter::parse_flags( FormatSpec &spec, const Char *&s) { - for (;;) { - switch (*s++) { - case '-': - spec.align_ = ALIGN_LEFT; - break; - case '+': - spec.flags_ |= SIGN_FLAG | PLUS_FLAG; - break; - case '0': - spec.fill_ = '0'; - break; - case ' ': - spec.flags_ |= SIGN_FLAG; - break; - case '#': - spec.flags_ |= HASH_FLAG; - break; - default: - --s; - return; - } + for (;;) { + switch (*s++) { + case '-': + spec.align_ = ALIGN_LEFT; + break; + case '+': + spec.flags_ |= SIGN_FLAG | PLUS_FLAG; + break; + case '0': + spec.fill_ = '0'; + break; + case ' ': + spec.flags_ |= SIGN_FLAG; + break; + case '#': + spec.flags_ |= HASH_FLAG; + break; + default: + --s; + return; } + } } template Arg fmt::internal::PrintfFormatter::get_arg( const Char *s, unsigned arg_index) { - const char *error = 0; - Arg arg = arg_index == UINT_MAX ? - next_arg(error) : FormatterBase::get_arg(arg_index - 1, error); - if (error) - FMT_THROW(FormatError(!*s ? "invalid format string" : error)); - return arg; + (void)s; + const char *error = 0; + Arg arg = arg_index == UINT_MAX ? + next_arg(error) : FormatterBase::get_arg(arg_index - 1, error); + if (error) + FMT_THROW(FormatError(!*s ? "invalid format string" : error)); + return arg; } template unsigned fmt::internal::PrintfFormatter::parse_header( - const Char *&s, FormatSpec &spec) { - unsigned arg_index = UINT_MAX; - Char c = *s; - if (c >= '0' && c <= '9') { - // Parse an argument index (if followed by '$') or a width possibly - // preceded with '0' flag(s). - unsigned value = parse_nonnegative_int(s); - if (*s == '$') { // value is an argument index - ++s; - arg_index = value; - } - else { - if (c == '0') - spec.fill_ = '0'; - if (value != 0) { - // Nonzero value means that we parsed width and don't need to - // parse it or flags again, so return now. - spec.width_ = value; - return arg_index; - } - } + const Char *&s, FormatSpec &spec) { + unsigned arg_index = UINT_MAX; + Char c = *s; + if (c >= '0' && c <= '9') { + // Parse an argument index (if followed by '$') or a width possibly + // preceded with '0' flag(s). + unsigned value = parse_nonnegative_int(s); + if (*s == '$') { // value is an argument index + ++s; + arg_index = value; + } else { + if (c == '0') + spec.fill_ = '0'; + if (value != 0) { + // Nonzero value means that we parsed width and don't need to + // parse it or flags again, so return now. + spec.width_ = value; + return arg_index; + } } - parse_flags(spec, s); - // Parse width. - if (*s >= '0' && *s <= '9') { - spec.width_ = parse_nonnegative_int(s); - } - else if (*s == '*') { - ++s; - spec.width_ = WidthHandler(spec).visit(get_arg(s)); - } - return arg_index; + } + parse_flags(spec, s); + // Parse width. + if (*s >= '0' && *s <= '9') { + spec.width_ = parse_nonnegative_int(s); + } else if (*s == '*') { + ++s; + spec.width_ = WidthHandler(spec).visit(get_arg(s)); + } + return arg_index; } template void fmt::internal::PrintfFormatter::format( BasicWriter &writer, BasicStringRef format_str, const ArgList &args) { - const Char *start = format_str.c_str(); - set_args(args); - const Char *s = start; - while (*s) { - Char c = *s++; - if (c != '%') continue; - if (*s == c) { - write(writer, start, s); - start = ++s; - continue; - } - write(writer, start, s - 1); - - FormatSpec spec; - spec.align_ = ALIGN_RIGHT; - - // Parse argument index, flags and width. - unsigned arg_index = parse_header(s, spec); - - // Parse precision. - if (*s == '.') { - ++s; - if ('0' <= *s && *s <= '9') { - spec.precision_ = parse_nonnegative_int(s); - } - else if (*s == '*') { - ++s; - spec.precision_ = PrecisionHandler().visit(get_arg(s)); - } - } - - Arg arg = get_arg(s, arg_index); - if (spec.flag(HASH_FLAG) && IsZeroInt().visit(arg)) - spec.flags_ &= ~HASH_FLAG; - if (spec.fill_ == '0') { - if (arg.type <= Arg::LAST_NUMERIC_TYPE) - spec.align_ = ALIGN_NUMERIC; - else - spec.fill_ = ' '; // Ignore '0' flag for non-numeric types. - } - - // Parse length and convert the argument to the required type. - switch (*s++) { - case 'h': - if (*s == 'h') - ArgConverter(arg, *++s).visit(arg); - else - ArgConverter(arg, *s).visit(arg); - break; - case 'l': - if (*s == 'l') - ArgConverter(arg, *++s).visit(arg); - else - ArgConverter(arg, *s).visit(arg); - break; - case 'j': - ArgConverter(arg, *s).visit(arg); - break; - case 'z': - ArgConverter(arg, *s).visit(arg); - break; - case 't': - ArgConverter(arg, *s).visit(arg); - break; - case 'L': - // printf produces garbage when 'L' is omitted for long double, no - // need to do the same. - break; - default: - --s; - ArgConverter(arg, *s).visit(arg); - } - - // Parse type. - if (!*s) - FMT_THROW(FormatError("invalid format string")); - spec.type_ = static_cast(*s++); - if (arg.type <= Arg::LAST_INTEGER_TYPE) { - // Normalize type. - switch (spec.type_) { - case 'i': - case 'u': - spec.type_ = 'd'; - break; - case 'c': - // TODO: handle wchar_t - CharConverter(arg).visit(arg); - break; - } - } - - start = s; - - // Format argument. - switch (arg.type) { - case Arg::INT: - writer.write_int(arg.int_value, spec); - break; - case Arg::UINT: - writer.write_int(arg.uint_value, spec); - break; - case Arg::LONG_LONG: - writer.write_int(arg.long_long_value, spec); - break; - case Arg::ULONG_LONG: - writer.write_int(arg.ulong_long_value, spec); - break; - case Arg::CHAR: { - if (spec.type_ && spec.type_ != 'c') - writer.write_int(arg.int_value, spec); - typedef typename BasicWriter::CharPtr CharPtr; - CharPtr out = CharPtr(); - if (spec.width_ > 1) { - Char fill = ' '; - out = writer.grow_buffer(spec.width_); - if (spec.align_ != ALIGN_LEFT) { - std::fill_n(out, spec.width_ - 1, fill); - out += spec.width_ - 1; - } - else { - std::fill_n(out + 1, spec.width_ - 1, fill); - } - } - else { - out = writer.grow_buffer(1); - } - *out = static_cast(arg.int_value); - break; - } - case Arg::DOUBLE: - writer.write_double(arg.double_value, spec); - break; - case Arg::LONG_DOUBLE: - writer.write_double(arg.long_double_value, spec); - break; - case Arg::CSTRING: - arg.string.size = 0; - writer.write_str(arg.string, spec); - break; - case Arg::STRING: - writer.write_str(arg.string, spec); - break; - case Arg::WSTRING: - writer.write_str(ignore_incompatible_str(arg.wstring), spec); - break; - case Arg::POINTER: - if (spec.type_ && spec.type_ != 'p') - internal::report_unknown_type(spec.type_, "pointer"); - spec.flags_ = HASH_FLAG; - spec.type_ = 'x'; - writer.write_int(reinterpret_cast(arg.pointer), spec); - break; - case Arg::CUSTOM: { - if (spec.type_) - internal::report_unknown_type(spec.type_, "object"); - const void *str_format = "s"; - arg.custom.format(&writer, arg.custom.value, &str_format); - break; - } - default: - assert(false); - break; - } + const Char *start = format_str.c_str(); + set_args(args); + const Char *s = start; + while (*s) { + Char c = *s++; + if (c != '%') continue; + if (*s == c) { + write(writer, start, s); + start = ++s; + continue; } - write(writer, start, s); + write(writer, start, s - 1); + + FormatSpec spec; + spec.align_ = ALIGN_RIGHT; + + // Parse argument index, flags and width. + unsigned arg_index = parse_header(s, spec); + + // Parse precision. + if (*s == '.') { + ++s; + if ('0' <= *s && *s <= '9') { + spec.precision_ = parse_nonnegative_int(s); + } else if (*s == '*') { + ++s; + spec.precision_ = PrecisionHandler().visit(get_arg(s)); + } + } + + Arg arg = get_arg(s, arg_index); + if (spec.flag(HASH_FLAG) && IsZeroInt().visit(arg)) + spec.flags_ &= ~HASH_FLAG; + if (spec.fill_ == '0') { + if (arg.type <= Arg::LAST_NUMERIC_TYPE) + spec.align_ = ALIGN_NUMERIC; + else + spec.fill_ = ' '; // Ignore '0' flag for non-numeric types. + } + + // Parse length and convert the argument to the required type. + switch (*s++) { + case 'h': + if (*s == 'h') + ArgConverter(arg, *++s).visit(arg); + else + ArgConverter(arg, *s).visit(arg); + break; + case 'l': + if (*s == 'l') + ArgConverter(arg, *++s).visit(arg); + else + ArgConverter(arg, *s).visit(arg); + break; + case 'j': + ArgConverter(arg, *s).visit(arg); + break; + case 'z': + ArgConverter(arg, *s).visit(arg); + break; + case 't': + ArgConverter(arg, *s).visit(arg); + break; + case 'L': + // printf produces garbage when 'L' is omitted for long double, no + // need to do the same. + break; + default: + --s; + ArgConverter(arg, *s).visit(arg); + } + + // Parse type. + if (!*s) + FMT_THROW(FormatError("invalid format string")); + spec.type_ = static_cast(*s++); + if (arg.type <= Arg::LAST_INTEGER_TYPE) { + // Normalize type. + switch (spec.type_) { + case 'i': case 'u': + spec.type_ = 'd'; + break; + case 'c': + // TODO: handle wchar_t + CharConverter(arg).visit(arg); + break; + } + } + + start = s; + + // Format argument. + switch (arg.type) { + case Arg::INT: + writer.write_int(arg.int_value, spec); + break; + case Arg::UINT: + writer.write_int(arg.uint_value, spec); + break; + case Arg::LONG_LONG: + writer.write_int(arg.long_long_value, spec); + break; + case Arg::ULONG_LONG: + writer.write_int(arg.ulong_long_value, spec); + break; + case Arg::CHAR: { + if (spec.type_ && spec.type_ != 'c') + writer.write_int(arg.int_value, spec); + typedef typename BasicWriter::CharPtr CharPtr; + CharPtr out = CharPtr(); + if (spec.width_ > 1) { + Char fill = ' '; + out = writer.grow_buffer(spec.width_); + if (spec.align_ != ALIGN_LEFT) { + std::fill_n(out, spec.width_ - 1, fill); + out += spec.width_ - 1; + } else { + std::fill_n(out + 1, spec.width_ - 1, fill); + } + } else { + out = writer.grow_buffer(1); + } + *out = static_cast(arg.int_value); + break; + } + case Arg::DOUBLE: + writer.write_double(arg.double_value, spec); + break; + case Arg::LONG_DOUBLE: + writer.write_double(arg.long_double_value, spec); + break; + case Arg::CSTRING: + arg.string.size = 0; + writer.write_str(arg.string, spec); + break; + case Arg::STRING: + writer.write_str(arg.string, spec); + break; + case Arg::WSTRING: + writer.write_str(ignore_incompatible_str(arg.wstring), spec); + break; + case Arg::POINTER: + if (spec.type_ && spec.type_ != 'p') + internal::report_unknown_type(spec.type_, "pointer"); + spec.flags_= HASH_FLAG; + spec.type_ = 'x'; + writer.write_int(reinterpret_cast(arg.pointer), spec); + break; + case Arg::CUSTOM: { + if (spec.type_) + internal::report_unknown_type(spec.type_, "object"); + const void *str_format = "s"; + arg.custom.format(&writer, arg.custom.value, &str_format); + break; + } + default: + assert(false); + break; + } + } + write(writer, start, s); } template const Char *fmt::BasicFormatter::format( const Char *&format_str, const Arg &arg) { - const Char *s = format_str; - FormatSpec spec; - if (*s == ':') { - if (arg.type == Arg::CUSTOM) { - arg.custom.format(this, arg.custom.value, &s); - return s; - } - ++s; - // Parse fill and alignment. - if (Char c = *s) { - const Char *p = s + 1; - spec.align_ = ALIGN_DEFAULT; - do { - switch (*p) { - case '<': - spec.align_ = ALIGN_LEFT; - break; - case '>': - spec.align_ = ALIGN_RIGHT; - break; - case '=': - spec.align_ = ALIGN_NUMERIC; - break; - case '^': - spec.align_ = ALIGN_CENTER; - break; - } - if (spec.align_ != ALIGN_DEFAULT) { - if (p != s) { - if (c == '}') break; - if (c == '{') - FMT_THROW(FormatError("invalid fill character '{'")); - s += 2; - spec.fill_ = c; - } - else ++s; - if (spec.align_ == ALIGN_NUMERIC) - require_numeric_argument(arg, '='); - break; - } - } while (--p >= s); - } - - // Parse sign. - switch (*s) { - case '+': - check_sign(s, arg); - spec.flags_ |= SIGN_FLAG | PLUS_FLAG; + const Char *s = format_str; + FormatSpec spec; + if (*s == ':') { + if (arg.type == Arg::CUSTOM) { + arg.custom.format(this, arg.custom.value, &s); + return s; + } + ++s; + // Parse fill and alignment. + if (Char c = *s) { + const Char *p = s + 1; + spec.align_ = ALIGN_DEFAULT; + do { + switch (*p) { + case '<': + spec.align_ = ALIGN_LEFT; break; - case '-': - check_sign(s, arg); - spec.flags_ |= MINUS_FLAG; + case '>': + spec.align_ = ALIGN_RIGHT; break; - case ' ': - check_sign(s, arg); - spec.flags_ |= SIGN_FLAG; + case '=': + spec.align_ = ALIGN_NUMERIC; + break; + case '^': + spec.align_ = ALIGN_CENTER; break; } - - if (*s == '#') { - require_numeric_argument(arg, '#'); - spec.flags_ |= HASH_FLAG; - ++s; + if (spec.align_ != ALIGN_DEFAULT) { + if (p != s) { + if (c == '}') break; + if (c == '{') + FMT_THROW(FormatError("invalid fill character '{'")); + s += 2; + spec.fill_ = c; + } else ++s; + if (spec.align_ == ALIGN_NUMERIC) + require_numeric_argument(arg, '='); + break; } - - // Parse width and zero flag. - if ('0' <= *s && *s <= '9') { - if (*s == '0') { - require_numeric_argument(arg, '0'); - spec.align_ = ALIGN_NUMERIC; - spec.fill_ = '0'; - } - // Zero may be parsed again as a part of the width, but it is simpler - // and more efficient than checking if the next char is a digit. - spec.width_ = parse_nonnegative_int(s); - } - - // Parse precision. - if (*s == '.') { - ++s; - spec.precision_ = 0; - if ('0' <= *s && *s <= '9') { - spec.precision_ = parse_nonnegative_int(s); - } - else if (*s == '{') { - ++s; - const Arg &precision_arg = parse_arg_index(s); - if (*s++ != '}') - FMT_THROW(FormatError("invalid format string")); - ULongLong value = 0; - switch (precision_arg.type) { - case Arg::INT: - if (precision_arg.int_value < 0) - FMT_THROW(FormatError("negative precision")); - value = precision_arg.int_value; - break; - case Arg::UINT: - value = precision_arg.uint_value; - break; - case Arg::LONG_LONG: - if (precision_arg.long_long_value < 0) - FMT_THROW(FormatError("negative precision")); - value = precision_arg.long_long_value; - break; - case Arg::ULONG_LONG: - value = precision_arg.ulong_long_value; - break; - default: - FMT_THROW(FormatError("precision is not integer")); - } - if (value > INT_MAX) - FMT_THROW(FormatError("number is too big")); - spec.precision_ = static_cast(value); - } - else { - FMT_THROW(FormatError("missing precision specifier")); - } - if (arg.type < Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) { - FMT_THROW(FormatError( - fmt::format("precision not allowed in {} format specifier", - arg.type == Arg::POINTER ? "pointer" : "integer"))); - } - } - - // Parse type. - if (*s != '}' && *s) - spec.type_ = static_cast(*s++); + } while (--p >= s); } - if (*s++ != '}') - FMT_THROW(FormatError("missing '}' in format string")); - start_ = s; + // Parse sign. + switch (*s) { + case '+': + check_sign(s, arg); + spec.flags_ |= SIGN_FLAG | PLUS_FLAG; + break; + case '-': + check_sign(s, arg); + spec.flags_ |= MINUS_FLAG; + break; + case ' ': + check_sign(s, arg); + spec.flags_ |= SIGN_FLAG; + break; + } - // Format argument. - internal::ArgFormatter(*this, spec, s - 1).visit(arg); - return s; + if (*s == '#') { + require_numeric_argument(arg, '#'); + spec.flags_ |= HASH_FLAG; + ++s; + } + + // Parse width and zero flag. + if ('0' <= *s && *s <= '9') { + if (*s == '0') { + require_numeric_argument(arg, '0'); + spec.align_ = ALIGN_NUMERIC; + spec.fill_ = '0'; + } + // Zero may be parsed again as a part of the width, but it is simpler + // and more efficient than checking if the next char is a digit. + spec.width_ = parse_nonnegative_int(s); + } + + // Parse precision. + if (*s == '.') { + ++s; + spec.precision_ = 0; + if ('0' <= *s && *s <= '9') { + spec.precision_ = parse_nonnegative_int(s); + } else if (*s == '{') { + ++s; + const Arg &precision_arg = parse_arg_index(s); + if (*s++ != '}') + FMT_THROW(FormatError("invalid format string")); + ULongLong value = 0; + switch (precision_arg.type) { + case Arg::INT: + if (precision_arg.int_value < 0) + FMT_THROW(FormatError("negative precision")); + value = precision_arg.int_value; + break; + case Arg::UINT: + value = precision_arg.uint_value; + break; + case Arg::LONG_LONG: + if (precision_arg.long_long_value < 0) + FMT_THROW(FormatError("negative precision")); + value = precision_arg.long_long_value; + break; + case Arg::ULONG_LONG: + value = precision_arg.ulong_long_value; + break; + default: + FMT_THROW(FormatError("precision is not integer")); + } + if (value > INT_MAX) + FMT_THROW(FormatError("number is too big")); + spec.precision_ = static_cast(value); + } else { + FMT_THROW(FormatError("missing precision specifier")); + } + if (arg.type < Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) { + FMT_THROW(FormatError( + fmt::format("precision not allowed in {} format specifier", + arg.type == Arg::POINTER ? "pointer" : "integer"))); + } + } + + // Parse type. + if (*s != '}' && *s) + spec.type_ = static_cast(*s++); + } + + if (*s++ != '}') + FMT_THROW(FormatError("missing '}' in format string")); + start_ = s; + + // Format argument. + internal::ArgFormatter(*this, spec, s - 1).visit(arg); + return s; } template void fmt::BasicFormatter::format( BasicStringRef format_str, const ArgList &args) { - const Char *s = start_ = format_str.c_str(); - set_args(args); - while (*s) { - Char c = *s++; - if (c != '{' && c != '}') continue; - if (*s == c) { - write(writer_, start_, s); - start_ = ++s; - continue; - } - if (c == '}') - FMT_THROW(FormatError("unmatched '}' in format string")); - write(writer_, start_, s - 1); - Arg arg = parse_arg_index(s); - s = format(s, arg); + const Char *s = start_ = format_str.c_str(); + set_args(args); + while (*s) { + Char c = *s++; + if (c != '{' && c != '}') continue; + if (*s == c) { + write(writer_, start_, s); + start_ = ++s; + continue; } - write(writer_, start_, s); + if (c == '}') + FMT_THROW(FormatError("unmatched '}' in format string")); + write(writer_, start_, s - 1); + Arg arg = parse_arg_index(s); + s = format(s, arg); + } + write(writer_, start_, s); } FMT_FUNC void fmt::report_system_error( - int error_code, fmt::StringRef message) FMT_NOEXCEPT{ - report_error(internal::format_system_error, error_code, message); + int error_code, fmt::StringRef message) FMT_NOEXCEPT { + report_error(internal::format_system_error, error_code, message); } #ifdef _WIN32 FMT_FUNC void fmt::report_windows_error( - int error_code, fmt::StringRef message) FMT_NOEXCEPT{ - report_error(internal::format_windows_error, error_code, message); + int error_code, fmt::StringRef message) FMT_NOEXCEPT { + report_error(internal::format_windows_error, error_code, message); } #endif FMT_FUNC void fmt::print(std::FILE *f, StringRef format_str, ArgList args) { - MemoryWriter w; - w.write(format_str, args); - std::fwrite(w.data(), 1, w.size(), f); + MemoryWriter w; + w.write(format_str, args); + std::fwrite(w.data(), 1, w.size(), f); } FMT_FUNC void fmt::print(StringRef format_str, ArgList args) { - print(stdout, format_str, args); + print(stdout, format_str, args); } FMT_FUNC void fmt::print(std::ostream &os, StringRef format_str, ArgList args) { - MemoryWriter w; - w.write(format_str, args); - os.write(w.data(), w.size()); + MemoryWriter w; + w.write(format_str, args); + os.write(w.data(), w.size()); } FMT_FUNC void fmt::print_colored(Color c, StringRef format, ArgList args) { - char escape[] = "\x1b[30m"; - escape[3] = '0' + static_cast(c); - std::fputs(escape, stdout); - print(format, args); - std::fputs(RESET_COLOR, stdout); + char escape[] = "\x1b[30m"; + escape[3] = '0' + static_cast(c); + std::fputs(escape, stdout); + print(format, args); + std::fputs(RESET_COLOR, stdout); } FMT_FUNC int fmt::fprintf(std::FILE *f, StringRef format, ArgList args) { - MemoryWriter w; - printf(w, format, args); - std::size_t size = w.size(); - return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast(size); + MemoryWriter w; + printf(w, format, args); + std::size_t size = w.size(); + return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast(size); } +#ifndef FMT_HEADER_ONLY + // Explicit instantiations for char. +template void fmt::internal::FixedBuffer::grow(std::size_t); + template const char *fmt::BasicFormatter::format( const char *&format_str, const fmt::internal::Arg &arg); template void fmt::BasicFormatter::format( - BasicStringRef format, const ArgList &args); + BasicStringRef format, const ArgList &args); template void fmt::internal::PrintfFormatter::format( - BasicWriter &writer, BasicStringRef format, const ArgList &args); + BasicWriter &writer, BasicStringRef format, const ArgList &args); template int fmt::internal::CharTraits::format_float( char *buffer, std::size_t size, const char *format, @@ -1162,6 +1180,8 @@ template int fmt::internal::CharTraits::format_float( // Explicit instantiations for wchar_t. +template void fmt::internal::FixedBuffer::grow(std::size_t); + template const wchar_t *fmt::BasicFormatter::format( const wchar_t *&format_str, const fmt::internal::Arg &arg); @@ -1180,6 +1200,8 @@ template int fmt::internal::CharTraits::format_float( wchar_t *buffer, std::size_t size, const wchar_t *format, unsigned width, int precision, long double value); +#endif // FMT_HEADER_ONLY + #if _MSC_VER # pragma warning(pop) #endif \ No newline at end of file diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h index c993b222..fd390caa 100644 --- a/include/spdlog/details/format.h +++ b/include/spdlog/details/format.h @@ -1,34 +1,34 @@ /* -Formatting library for C++ + Formatting library for C++ -Copyright (c) 2012 - 2014, Victor Zverovich -All rights reserved. + Copyright (c) 2012 - 2015, Victor Zverovich + All rights reserved. -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: -1. Redistributions of source code must retain the above copyright notice, this -list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, -this list of conditions and the following disclaimer in the documentation -and/or other materials provided with the distribution. + 1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ #ifndef FMT_FORMAT_H_ #define FMT_FORMAT_H_ -#define FMT_HEADER_ONLY +#ifdef FMT_HEADER_ONLY #include @@ -49,16 +49,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifdef _MSC_VER # include // _BitScanReverse, _BitScanReverse64 -namespace fmt -{ -namespace internal -{ +namespace fmt { +namespace internal { # pragma intrinsic(_BitScanReverse) -inline uint32_t clz(uint32_t x) -{ - unsigned long r = 0; - _BitScanReverse(&r, x); - return 31 - r; +inline uint32_t clz(uint32_t x) { + unsigned long r = 0; + _BitScanReverse(&r, x); + return 31 - r; } # define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n) @@ -66,20 +63,19 @@ inline uint32_t clz(uint32_t x) # pragma intrinsic(_BitScanReverse64) # endif -inline uint32_t clzll(uint64_t x) -{ - unsigned long r = 0; +inline uint32_t clzll(uint64_t x) { + unsigned long r = 0; # ifdef _WIN64 - _BitScanReverse64(&r, x); + _BitScanReverse64(&r, x); # else - // Scan the high 32 bits. - if (_BitScanReverse(&r, static_cast(x >> 32))) - return 63 - (r + 32); + // Scan the high 32 bits. + if (_BitScanReverse(&r, static_cast(x >> 32))) + return 63 - (r + 32); - // Scan the low 32 bits. - _BitScanReverse(&r, static_cast(x)); + // Scan the low 32 bits. + _BitScanReverse(&r, static_cast(x)); # endif - return 63 - r; + return 63 - r; } # define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n) } @@ -178,8 +174,7 @@ inline uint32_t clzll(uint64_t x) TypeName& operator=(const TypeName&) #endif -namespace fmt -{ +namespace fmt { // Fix the warning about long long on older versions of GCC // that don't support the diagnostic pragma. @@ -203,106 +198,93 @@ template void format(BasicFormatter &f, const Char *&format_str, const T &value); /** -\rst -A string reference. It can be constructed from a C string or -``std::string``. + \rst + A string reference. It can be constructed from a C string or + ``std::string``. + + You can use one of the following typedefs for common character types: -You can use one of the following typedefs for common character types: + +------------+-------------------------+ + | Type | Definition | + +============+=========================+ + | StringRef | BasicStringRef | + +------------+-------------------------+ + | WStringRef | BasicStringRef | + +------------+-------------------------+ -+------------+-------------------------+ -| Type | Definition | -+============+=========================+ -| StringRef | BasicStringRef | -+------------+-------------------------+ -| WStringRef | BasicStringRef | -+------------+-------------------------+ + This class is most useful as a parameter type to allow passing + different types of strings to a function, for example:: -This class is most useful as a parameter type to allow passing -different types of strings to a function, for example:: + template + std::string format(StringRef format_str, const Args & ... args); -template -std::string format(StringRef format_str, const Args & ... args); - -format("{}", 42); -format(std::string("{}"), 42); -\endrst -*/ + format("{}", 42); + format(std::string("{}"), 42); + \endrst + */ template -class BasicStringRef -{ -private: - const Char *data_; - std::size_t size_; +class BasicStringRef { + private: + const Char *data_; + std::size_t size_; -public: - /** + public: + /** Constructs a string reference object from a C string and a size. - */ - BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {} + */ + BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {} - /** + /** Constructs a string reference object from a C string computing the size with ``std::char_traits::length``. - */ - BasicStringRef(const Char *s) - : data_(s), size_(std::char_traits::length(s)) {} + */ + BasicStringRef(const Char *s) + : data_(s), size_(std::char_traits::length(s)) {} - /** + /** Constructs a string reference from an `std::string` object. - */ - BasicStringRef(const std::basic_string &s) - : data_(s.c_str()), size_(s.size()) {} + */ + BasicStringRef(const std::basic_string &s) + : data_(s.c_str()), size_(s.size()) {} - /** + /** Converts a string reference to an `std::string` object. - */ - operator std::basic_string() const - { - return std::basic_string(data_, size()); - } + */ + operator std::basic_string() const { + return std::basic_string(data_, size()); + } - /** + /** Returns the pointer to a C string. - */ - const Char *c_str() const - { - return data_; - } + */ + const Char *c_str() const { return data_; } - /** + /** Returns the string size. - */ - std::size_t size() const - { - return size_; - } + */ + std::size_t size() const { return size_; } - friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) - { - return lhs.data_ == rhs.data_; - } - friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) - { - return lhs.data_ != rhs.data_; - } + friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.data_ == rhs.data_; + } + friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.data_ != rhs.data_; + } }; typedef BasicStringRef StringRef; typedef BasicStringRef WStringRef; /** -A formatting error such as invalid format string. + A formatting error such as invalid format string. */ -class FormatError : public std::runtime_error -{ -public: - explicit FormatError(StringRef message) - : std::runtime_error(message.c_str()) {} +class FormatError : public std::runtime_error { + public: + explicit FormatError(StringRef message) + : std::runtime_error(message.c_str()) {} }; -namespace internal -{ - +namespace internal { // The number of characters to store in the MemoryBuffer object itself // to avoid dynamic memory allocation. enum { INLINE_BUFFER_SIZE = 500 }; @@ -310,249 +292,211 @@ enum { INLINE_BUFFER_SIZE = 500 }; #if _SECURE_SCL // Use checked iterator to avoid warnings on MSVC. template -inline stdext::checked_array_iterator make_ptr(T *ptr, std::size_t size) -{ - return stdext::checked_array_iterator(ptr, size); +inline stdext::checked_array_iterator make_ptr(T *ptr, std::size_t size) { + return stdext::checked_array_iterator(ptr, size); } #else template -inline T *make_ptr(T *ptr, std::size_t) -{ - return ptr; -} +inline T *make_ptr(T *ptr, std::size_t) { return ptr; } #endif +} // namespace internal -// A buffer for POD types. It supports a subset of std::vector's operations. +/** A buffer supporting a subset of ``std::vector``'s operations. */ template -class Buffer -{ -private: - FMT_DISALLOW_COPY_AND_ASSIGN(Buffer); +class Buffer { + private: + FMT_DISALLOW_COPY_AND_ASSIGN(Buffer); -protected: - T *ptr_; - std::size_t size_; - std::size_t capacity_; + protected: + T *ptr_; + std::size_t size_; + std::size_t capacity_; - Buffer(T *ptr = 0, std::size_t capacity = 0) - : ptr_(ptr), size_(0), capacity_(capacity) {} + Buffer(T *ptr = 0, std::size_t capacity = 0) + : ptr_(ptr), size_(0), capacity_(capacity) {} - virtual void grow(std::size_t size) = 0; + /** + Increases the buffer capacity to hold at least *size* elements updating + ``ptr_`` and ``capacity_``. + */ + virtual void grow(std::size_t size) = 0; -public: - virtual ~Buffer() {} + public: + virtual ~Buffer() {} - // Returns the size of this buffer. - std::size_t size() const - { - return size_; - } + /** Returns the size of this buffer. */ + std::size_t size() const { return size_; } - // Returns the capacity of this buffer. - std::size_t capacity() const - { - return capacity_; - } + /** Returns the capacity of this buffer. */ + std::size_t capacity() const { return capacity_; } - // Resizes the buffer. If T is a POD type new elements are not initialized. - void resize(std::size_t new_size) - { - if (new_size > capacity_) - grow(new_size); - size_ = new_size; - } + /** + Resizes the buffer. If T is a POD type new elements may not be initialized. + */ + void resize(std::size_t new_size) { + if (new_size > capacity_) + grow(new_size); + size_ = new_size; + } - // Reserves space to store at least capacity elements. - void reserve(std::size_t capacity) - { - if (capacity > capacity_) - grow(capacity); - } + /** Reserves space to store at least *capacity* elements. */ + void reserve(std::size_t capacity) { + if (capacity > capacity_) + grow(capacity); + } - void clear() FMT_NOEXCEPT { size_ = 0; } + void clear() FMT_NOEXCEPT { size_ = 0; } - void push_back(const T &value) - { - if (size_ == capacity_) - grow(size_ + 1); - ptr_[size_++] = value; - } + void push_back(const T &value) { + if (size_ == capacity_) + grow(size_ + 1); + ptr_[size_++] = value; + } - // Appends data to the end of the buffer. - void append(const T *begin, const T *end); + /** Appends data to the end of the buffer. */ + void append(const T *begin, const T *end); - T &operator[](std::size_t index) - { - return ptr_[index]; - } - const T &operator[](std::size_t index) const - { - return ptr_[index]; - } + T &operator[](std::size_t index) { return ptr_[index]; } + const T &operator[](std::size_t index) const { return ptr_[index]; } }; template -void Buffer::append(const T *begin, const T *end) -{ - std::ptrdiff_t num_elements = end - begin; - if (size_ + num_elements > capacity_) - grow(size_ + num_elements); - std::copy(begin, end, make_ptr(ptr_, capacity_) + size_); - size_ += num_elements; +void Buffer::append(const T *begin, const T *end) { + std::ptrdiff_t num_elements = end - begin; + if (size_ + num_elements > capacity_) + grow(size_ + num_elements); + std::copy(begin, end, internal::make_ptr(ptr_, capacity_) + size_); + size_ += num_elements; } +namespace internal { + // A memory buffer for POD types with the first SIZE elements stored in // the object itself. template > -class MemoryBuffer : private Allocator, public Buffer -{ -private: - T data_[SIZE]; +class MemoryBuffer : private Allocator, public Buffer { + private: + T data_[SIZE]; - // Free memory allocated by the buffer. - void free() - { - if (this->ptr_ != data_) this->deallocate(this->ptr_, this->capacity_); - } + // Free memory allocated by the buffer. + void free() { + if (this->ptr_ != data_) this->deallocate(this->ptr_, this->capacity_); + } -protected: - void grow(std::size_t size); + protected: + void grow(std::size_t size); -public: - explicit MemoryBuffer(const Allocator &alloc = Allocator()) - : Allocator(alloc), Buffer(data_, SIZE) {} - ~MemoryBuffer() - { - free(); - } + public: + explicit MemoryBuffer(const Allocator &alloc = Allocator()) + : Allocator(alloc), Buffer(data_, SIZE) {} + ~MemoryBuffer() { free(); } #if FMT_USE_RVALUE_REFERENCES -private: - // Move data from other to this buffer. - void move(MemoryBuffer &other) - { - Allocator &this_alloc = *this, &other_alloc = other; - this_alloc = std::move(other_alloc); - this->size_ = other.size_; - this->capacity_ = other.capacity_; - if (other.ptr_ == other.data_) - { - this->ptr_ = data_; - std::copy(other.data_, - other.data_ + this->size_, make_ptr(data_, this->capacity_)); - } - else - { - this->ptr_ = other.ptr_; - // Set pointer to the inline array so that delete is not called - // when freeing. - other.ptr_ = other.data_; - } + private: + // Move data from other to this buffer. + void move(MemoryBuffer &other) { + Allocator &this_alloc = *this, &other_alloc = other; + this_alloc = std::move(other_alloc); + this->size_ = other.size_; + this->capacity_ = other.capacity_; + if (other.ptr_ == other.data_) { + this->ptr_ = data_; + std::copy(other.data_, + other.data_ + this->size_, make_ptr(data_, this->capacity_)); + } else { + this->ptr_ = other.ptr_; + // Set pointer to the inline array so that delete is not called + // when freeing. + other.ptr_ = other.data_; } + } -public: - MemoryBuffer(MemoryBuffer &&other) - { - move(other); - } + public: + MemoryBuffer(MemoryBuffer &&other) { + move(other); + } - MemoryBuffer &operator=(MemoryBuffer &&other) - { - assert(this != &other); - free(); - move(other); - return *this; - } + MemoryBuffer &operator=(MemoryBuffer &&other) { + assert(this != &other); + free(); + move(other); + return *this; + } #endif - // Returns a copy of the allocator associated with this buffer. - Allocator get_allocator() const - { - return *this; - } + // Returns a copy of the allocator associated with this buffer. + Allocator get_allocator() const { return *this; } }; template -void MemoryBuffer::grow(std::size_t size) -{ - std::size_t new_capacity = - (std::max)(size, this->capacity_ + this->capacity_ / 2); - T *new_ptr = this->allocate(new_capacity); - // The following code doesn't throw, so the raw pointer above doesn't leak. - std::copy(this->ptr_, - this->ptr_ + this->size_, make_ptr(new_ptr, new_capacity)); - std::size_t old_capacity = this->capacity_; - T *old_ptr = this->ptr_; - this->capacity_ = new_capacity; - this->ptr_ = new_ptr; - // deallocate may throw (at least in principle), but it doesn't matter since - // the buffer already uses the new storage and will deallocate it in case - // of exception. - if (old_ptr != data_) - this->deallocate(old_ptr, old_capacity); +void MemoryBuffer::grow(std::size_t size) { + std::size_t new_capacity = + (std::max)(size, this->capacity_ + this->capacity_ / 2); + T *new_ptr = this->allocate(new_capacity); + // The following code doesn't throw, so the raw pointer above doesn't leak. + std::copy(this->ptr_, + this->ptr_ + this->size_, make_ptr(new_ptr, new_capacity)); + std::size_t old_capacity = this->capacity_; + T *old_ptr = this->ptr_; + this->capacity_ = new_capacity; + this->ptr_ = new_ptr; + // deallocate may throw (at least in principle), but it doesn't matter since + // the buffer already uses the new storage and will deallocate it in case + // of exception. + if (old_ptr != data_) + this->deallocate(old_ptr, old_capacity); } +// A fixed-size buffer. +template +class FixedBuffer : public fmt::Buffer { + public: + FixedBuffer(Char *array, std::size_t size) : fmt::Buffer(array, size) {} + + protected: + void grow(std::size_t size); +}; + #ifndef _MSC_VER // Portable version of signbit. -inline int getsign(double x) -{ - // When compiled in C++11 mode signbit is no longer a macro but a function - // defined in namespace std and the macro is undefined. +inline int getsign(double x) { + // When compiled in C++11 mode signbit is no longer a macro but a function + // defined in namespace std and the macro is undefined. # ifdef signbit - return signbit(x); + return signbit(x); # else - return std::signbit(x); + return std::signbit(x); # endif } // Portable version of isinf. # ifdef isinf -inline int isinfinity(double x) -{ - return isinf(x); -} -inline int isinfinity(long double x) -{ - return isinf(x); -} +inline int isinfinity(double x) { return isinf(x); } +inline int isinfinity(long double x) { return isinf(x); } # else -inline int isinfinity(double x) -{ - return std::isinf(x); -} -inline int isinfinity(long double x) -{ - return std::isinf(x); -} +inline int isinfinity(double x) { return std::isinf(x); } +inline int isinfinity(long double x) { return std::isinf(x); } # endif #else -inline int getsign(double value) -{ - if (value < 0) return 1; - if (value == value) return 0; - int dec = 0, sign = 0; - char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail. - _ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign); - return sign; -} -inline int isinfinity(double x) -{ - return !_finite(x); -} -inline int isinfinity(long double x) -{ - return !_finite(static_cast(x)); +inline int getsign(double value) { + if (value < 0) return 1; + if (value == value) return 0; + int dec = 0, sign = 0; + char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail. + _ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign); + return sign; } +inline int isinfinity(double x) { return !_finite(x); } +inline int isinfinity(long double x) { return !_finite(static_cast(x)); } #endif template -class BasicCharTraits -{ -public: +class BasicCharTraits { + public: #if _SECURE_SCL - typedef stdext::checked_array_iterator CharPtr; + typedef stdext::checked_array_iterator CharPtr; #else - typedef Char *CharPtr; + typedef Char *CharPtr; #endif }; @@ -560,99 +504,69 @@ template class CharTraits; template <> -class CharTraits : public BasicCharTraits -{ -private: - // Conversion from wchar_t to char is not allowed. - static char convert(wchar_t); +class CharTraits : public BasicCharTraits { + private: + // Conversion from wchar_t to char is not allowed. + static char convert(wchar_t); public: - static char convert(char value) - { - return value; - } + static char convert(char value) { return value; } - // Formats a floating-point number. - template - static int format_float(char *buffer, std::size_t size, - const char *format, unsigned width, int precision, T value); + // Formats a floating-point number. + template + static int format_float(char *buffer, std::size_t size, + const char *format, unsigned width, int precision, T value); }; template <> -class CharTraits : public BasicCharTraits -{ -public: - static wchar_t convert(char value) - { - return value; - } - static wchar_t convert(wchar_t value) - { - return value; - } +class CharTraits : public BasicCharTraits { + public: + static wchar_t convert(char value) { return value; } + static wchar_t convert(wchar_t value) { return value; } - template - static int format_float(wchar_t *buffer, std::size_t size, - const wchar_t *format, unsigned width, int precision, T value); + template + static int format_float(wchar_t *buffer, std::size_t size, + const wchar_t *format, unsigned width, int precision, T value); }; // Checks if a number is negative - used to avoid warnings. template -struct SignChecker -{ - template - static bool is_negative(T value) - { - return value < 0; - } +struct SignChecker { + template + static bool is_negative(T value) { return value < 0; } }; template <> -struct SignChecker -{ - template - static bool is_negative(T) - { - return false; - } +struct SignChecker { + template + static bool is_negative(T) { return false; } }; // Returns true if value is negative, false otherwise. // Same as (value < 0) but doesn't produce warnings if T is an unsigned type. template -inline bool is_negative(T value) -{ - return SignChecker::is_signed>::is_negative(value); +inline bool is_negative(T value) { + return SignChecker::is_signed>::is_negative(value); } // Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise. template -struct TypeSelector -{ - typedef uint32_t Type; -}; +struct TypeSelector { typedef uint32_t Type; }; template <> -struct TypeSelector -{ - typedef uint64_t Type; -}; +struct TypeSelector { typedef uint64_t Type; }; template -struct IntTraits -{ - // Smallest of uint32_t and uint64_t that is large enough to represent - // all values of T. - typedef typename +struct IntTraits { + // Smallest of uint32_t and uint64_t that is large enough to represent + // all values of T. + typedef typename TypeSelector::digits <= 32>::Type MainType; }; // MakeUnsigned::Type gives an unsigned type corresponding to integer type T. template -struct MakeUnsigned -{ - typedef T Type; -}; +struct MakeUnsigned { typedef T Type; }; #define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \ template <> \ @@ -670,11 +584,10 @@ void report_unknown_type(char code, const char *type); // Static data is placed in this class template to allow header-only // configuration. template -struct BasicData -{ - static const uint32_t POWERS_OF_10_32[]; - static const uint64_t POWERS_OF_10_64[]; - static const char DIGITS[]; +struct BasicData { + static const uint32_t POWERS_OF_10_32[]; + static const uint64_t POWERS_OF_10_64[]; + static const char DIGITS[]; }; typedef BasicData<> Data; @@ -690,127 +603,94 @@ typedef BasicData<> Data; #ifdef FMT_BUILTIN_CLZLL // Returns the number of decimal digits in n. Leading zeros are not counted // except for n == 0 in which case count_digits returns 1. -inline unsigned count_digits(uint64_t n) -{ - // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 - // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. - unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; - return t - (n < Data::POWERS_OF_10_64[t]) + 1; +inline unsigned count_digits(uint64_t n) { + // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 + // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. + unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; + return t - (n < Data::POWERS_OF_10_64[t]) + 1; } #else // Fallback version of count_digits used when __builtin_clz is not available. -inline unsigned count_digits(uint64_t n) -{ - unsigned count = 1; - for (;;) - { - // Integer division is slow so do it for a group of four digits instead - // of for every digit. The idea comes from the talk by Alexandrescu - // "Three Optimization Tips for C++". See speed-test for a comparison. - if (n < 10) return count; - if (n < 100) return count + 1; - if (n < 1000) return count + 2; - if (n < 10000) return count + 3; - n /= 10000u; - count += 4; - } +inline unsigned count_digits(uint64_t n) { + unsigned count = 1; + for (;;) { + // Integer division is slow so do it for a group of four digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + if (n < 10) return count; + if (n < 100) return count + 1; + if (n < 1000) return count + 2; + if (n < 10000) return count + 3; + n /= 10000u; + count += 4; + } } #endif #ifdef FMT_BUILTIN_CLZ // Optional version of count_digits for better performance on 32-bit platforms. -inline unsigned count_digits(uint32_t n) -{ - uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; - return t - (n < Data::POWERS_OF_10_32[t]) + 1; +inline unsigned count_digits(uint32_t n) { + uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; + return t - (n < Data::POWERS_OF_10_32[t]) + 1; } #endif // Formats a decimal unsigned integer value writing into buffer. template -inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) -{ - --num_digits; - while (value >= 100) - { - // Integer division is slow so do it for a group of two digits instead - // of for every digit. The idea comes from the talk by Alexandrescu - // "Three Optimization Tips for C++". See speed-test for a comparison. - unsigned index = (value % 100) * 2; - value /= 100; - buffer[num_digits] = Data::DIGITS[index + 1]; - buffer[num_digits - 1] = Data::DIGITS[index]; - num_digits -= 2; - } - if (value < 10) - { - *buffer = static_cast('0' + value); - return; - } - unsigned index = static_cast(value * 2); - buffer[1] = Data::DIGITS[index + 1]; - buffer[0] = Data::DIGITS[index]; +inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { + --num_digits; + while (value >= 100) { + // Integer division is slow so do it for a group of two digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + unsigned index = (value % 100) * 2; + value /= 100; + buffer[num_digits] = Data::DIGITS[index + 1]; + buffer[num_digits - 1] = Data::DIGITS[index]; + num_digits -= 2; + } + if (value < 10) { + *buffer = static_cast('0' + value); + return; + } + unsigned index = static_cast(value * 2); + buffer[1] = Data::DIGITS[index + 1]; + buffer[0] = Data::DIGITS[index]; } #ifdef _WIN32 // A converter from UTF-8 to UTF-16. // It is only provided for Windows since other systems support UTF-8 natively. -class UTF8ToUTF16 -{ -private: - MemoryBuffer buffer_; +class UTF8ToUTF16 { + private: + MemoryBuffer buffer_; -public: - explicit UTF8ToUTF16(StringRef s); - operator WStringRef() const - { - return WStringRef(&buffer_[0], size()); - } - size_t size() const - { - return buffer_.size() - 1; - } - const wchar_t *c_str() const - { - return &buffer_[0]; - } - std::wstring str() const - { - return std::wstring(&buffer_[0], size()); - } + public: + explicit UTF8ToUTF16(StringRef s); + operator WStringRef() const { return WStringRef(&buffer_[0], size()); } + size_t size() const { return buffer_.size() - 1; } + const wchar_t *c_str() const { return &buffer_[0]; } + std::wstring str() const { return std::wstring(&buffer_[0], size()); } }; // A converter from UTF-16 to UTF-8. // It is only provided for Windows since other systems support UTF-8 natively. -class UTF16ToUTF8 -{ -private: - MemoryBuffer buffer_; +class UTF16ToUTF8 { + private: + MemoryBuffer buffer_; -public: - UTF16ToUTF8() {} - explicit UTF16ToUTF8(WStringRef s); - operator StringRef() const - { - return StringRef(&buffer_[0], size()); - } - size_t size() const - { - return buffer_.size() - 1; - } - const char *c_str() const - { - return &buffer_[0]; - } - std::string str() const - { - return std::string(&buffer_[0], size()); - } + public: + UTF16ToUTF8() {} + explicit UTF16ToUTF8(WStringRef s); + operator StringRef() const { return StringRef(&buffer_[0], size()); } + size_t size() const { return buffer_.size() - 1; } + const char *c_str() const { return &buffer_[0]; } + std::string str() const { return std::string(&buffer_[0], size()); } - // Performs conversion returning a system error code instead of - // throwing exception on conversion error. This method may still throw - // in case of memory allocation error. - int convert(WStringRef s); + // Performs conversion returning a system error code instead of + // throwing exception on conversion error. This method may still throw + // in case of memory allocation error. + int convert(WStringRef s); }; #endif @@ -822,231 +702,255 @@ void format_windows_error(fmt::Writer &out, int error_code, fmt::StringRef message) FMT_NOEXCEPT; #endif -// Computes max(Arg, 1) at compile time. It is used to avoid errors about +// Computes max(N, 1) at compile time. It is used to avoid errors about // allocating an array of 0 size. -template -struct NonZero -{ - enum { VALUE = Arg }; +template +struct NonZero { + enum { VALUE = N > 0 ? N : 1 }; }; -template <> -struct NonZero<0> -{ - enum { VALUE = 1 }; +// A formatting argument value. +struct Value { + template + struct StringValue { + const Char *value; + std::size_t size; + }; + + typedef void (*FormatFunc)( + void *formatter, const void *arg, void *format_str_ptr); + + struct CustomValue { + const void *value; + FormatFunc format; + }; + + union { + int int_value; + unsigned uint_value; + LongLong long_long_value; + ULongLong ulong_long_value; + double double_value; + long double long_double_value; + const void *pointer; + StringValue string; + StringValue sstring; + StringValue ustring; + StringValue wstring; + CustomValue custom; + }; + + enum Type { + NONE, + // Integer types should go first, + INT, UINT, LONG_LONG, ULONG_LONG, CHAR, LAST_INTEGER_TYPE = CHAR, + // followed by floating-point types. + DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE, + CSTRING, STRING, WSTRING, POINTER, CUSTOM + }; }; -// The value of a formatting argument. It is a POD type to allow storage in +// A formatting argument. It is a POD type to allow storage in // internal::MemoryBuffer. -struct Value -{ - template - struct StringValue - { - const Char *value; - std::size_t size; - }; - - typedef void(*FormatFunc)( - void *formatter, const void *arg, void *format_str_ptr); - - struct CustomValue - { - const void *value; - FormatFunc format; - }; - - union - { - int int_value; - unsigned uint_value; - LongLong long_long_value; - ULongLong ulong_long_value; - double double_value; - long double long_double_value; - const void *pointer; - StringValue string; - StringValue sstring; - StringValue ustring; - StringValue wstring; - CustomValue custom; - }; +struct Arg : Value { + Type type; }; -struct Arg : Value -{ - enum Type - { - NONE, - // Integer types should go first, - INT, UINT, LONG_LONG, ULONG_LONG, CHAR, LAST_INTEGER_TYPE = CHAR, - // followed by floating-point types. - DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE, - CSTRING, STRING, WSTRING, POINTER, CUSTOM - }; - Type type; -}; - -template +template struct None {}; // A helper class template to enable or disable overloads taking wide // characters and strings in MakeValue. template -struct WCharHelper -{ - typedef None Supported; - typedef T Unsupported; +struct WCharHelper { + typedef None Supported; + typedef T Unsupported; }; template -struct WCharHelper -{ - typedef T Supported; - typedef None Unsupported; +struct WCharHelper { + typedef T Supported; + typedef None Unsupported; }; -// Makes a Value object from any type. +template +class IsConvertibleToInt { + private: + typedef char yes[1]; + typedef char no[2]; + + static const T &get(); + + static yes &check(fmt::ULongLong); + static no &check(...); + + public: + enum { value = (sizeof(check(get())) == sizeof(yes)) }; +}; + +#define FMT_CONVERTIBLE_TO_INT(Type) \ + template <> \ + class IsConvertibleToInt { \ + public: \ + enum { value = 1 }; \ + } + +// Silence warnings about convering float to int. +FMT_CONVERTIBLE_TO_INT(float); +FMT_CONVERTIBLE_TO_INT(double); +FMT_CONVERTIBLE_TO_INT(long double); + +template +struct EnableIf {}; + +template +struct EnableIf { typedef T type; }; + +template +struct Conditional { typedef T type; }; + +template +struct Conditional { typedef F type; }; + +// A helper function to suppress bogus "conditional expression is constant" +// warnings. +inline bool check(bool value) { return value; } + +// Makes an Arg object from any type. template -class MakeValue : public Value -{ -private: - // The following two methods are private to disallow formatting of - // arbitrary pointers. If you want to output a pointer cast it to - // "void *" or "const void *". In particular, this forbids formatting - // of "[const] volatile char *" which is printed as bool by iostreams. - // Do not implement! - template - MakeValue(const T *value); - template - MakeValue(T *value); +class MakeValue : public Arg { + private: + // The following two methods are private to disallow formatting of + // arbitrary pointers. If you want to output a pointer cast it to + // "void *" or "const void *". In particular, this forbids formatting + // of "[const] volatile char *" which is printed as bool by iostreams. + // Do not implement! + template + MakeValue(const T *value); + template + MakeValue(T *value); - // The following methods are private to disallow formatting of wide - // characters and strings into narrow strings as in - // fmt::format("{}", L"test"); - // To fix this, use a wide format string: fmt::format(L"{}", L"test"). - MakeValue(typename WCharHelper::Unsupported); - MakeValue(typename WCharHelper::Unsupported); - MakeValue(typename WCharHelper::Unsupported); - MakeValue(typename WCharHelper::Unsupported); - MakeValue(typename WCharHelper::Unsupported); + // The following methods are private to disallow formatting of wide + // characters and strings into narrow strings as in + // fmt::format("{}", L"test"); + // To fix this, use a wide format string: fmt::format(L"{}", L"test"). + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); - void set_string(StringRef str) - { - string.value = str.c_str(); - string.size = str.size(); - } + void set_string(StringRef str) { + string.value = str.c_str(); + string.size = str.size(); + } - void set_string(WStringRef str) - { - wstring.value = str.c_str(); - wstring.size = str.size(); - } + void set_string(WStringRef str) { + wstring.value = str.c_str(); + wstring.size = str.size(); + } - // Formats an argument of a custom type, such as a user-defined class. - template - static void format_custom_arg( - void *formatter, const void *arg, void *format_str_ptr) - { - format(*static_cast*>(formatter), - *static_cast(format_str_ptr), - *static_cast(arg)); - } + // Formats an argument of a custom type, such as a user-defined class. + template + static void format_custom_arg( + void *formatter, const void *arg, void *format_str_ptr) { + format(*static_cast*>(formatter), + *static_cast(format_str_ptr), + *static_cast(arg)); + } -public: - MakeValue() {} + public: + MakeValue() {} #define FMT_MAKE_VALUE(Type, field, TYPE) \ MakeValue(Type value) { field = value; } \ static uint64_t type(Type) { return Arg::TYPE; } - FMT_MAKE_VALUE(bool, int_value, INT) - FMT_MAKE_VALUE(short, int_value, INT) - FMT_MAKE_VALUE(unsigned short, uint_value, UINT) - FMT_MAKE_VALUE(int, int_value, INT) - FMT_MAKE_VALUE(unsigned, uint_value, UINT) + FMT_MAKE_VALUE(bool, int_value, INT) + FMT_MAKE_VALUE(short, int_value, INT) + FMT_MAKE_VALUE(unsigned short, uint_value, UINT) + FMT_MAKE_VALUE(int, int_value, INT) + FMT_MAKE_VALUE(unsigned, uint_value, UINT) - MakeValue(long value) - { - // To minimize the number of types we need to deal with, long is - // translated either to int or to long long depending on its size. - if (sizeof(long) == sizeof(int)) - int_value = static_cast(value); - else - long_long_value = value; - } - static uint64_t type(long) - { - return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG; - } + MakeValue(long value) { + // To minimize the number of types we need to deal with, long is + // translated either to int or to long long depending on its size. + if (check(sizeof(long) == sizeof(int))) + int_value = static_cast(value); + else + long_long_value = value; + } + static uint64_t type(long) { + return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG; + } - MakeValue(unsigned long value) - { - if (sizeof(unsigned long) == sizeof(unsigned)) - uint_value = static_cast(value); - else - ulong_long_value = value; - } - static uint64_t type(unsigned long) - { - return sizeof(unsigned long) == sizeof(unsigned) ? - Arg::UINT : Arg::ULONG_LONG; - } + MakeValue(unsigned long value) { + if (check(sizeof(unsigned long) == sizeof(unsigned))) + uint_value = static_cast(value); + else + ulong_long_value = value; + } + static uint64_t type(unsigned long) { + return sizeof(unsigned long) == sizeof(unsigned) ? + Arg::UINT : Arg::ULONG_LONG; + } - FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG) - FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG) - FMT_MAKE_VALUE(float, double_value, DOUBLE) - FMT_MAKE_VALUE(double, double_value, DOUBLE) - FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE) - FMT_MAKE_VALUE(signed char, int_value, CHAR) - FMT_MAKE_VALUE(unsigned char, int_value, CHAR) - FMT_MAKE_VALUE(char, int_value, CHAR) + FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG) + FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG) + FMT_MAKE_VALUE(float, double_value, DOUBLE) + FMT_MAKE_VALUE(double, double_value, DOUBLE) + FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE) + FMT_MAKE_VALUE(signed char, int_value, CHAR) + FMT_MAKE_VALUE(unsigned char, int_value, CHAR) + FMT_MAKE_VALUE(char, int_value, CHAR) - MakeValue(typename WCharHelper::Supported value) - { - int_value = value; - } - static uint64_t type(wchar_t) - { - return Arg::CHAR; - } + MakeValue(typename WCharHelper::Supported value) { + int_value = value; + } + static uint64_t type(wchar_t) { return Arg::CHAR; } #define FMT_MAKE_STR_VALUE(Type, TYPE) \ MakeValue(Type value) { set_string(value); } \ static uint64_t type(Type) { return Arg::TYPE; } - FMT_MAKE_VALUE(char *, string.value, CSTRING) - FMT_MAKE_VALUE(const char *, string.value, CSTRING) - FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING) - FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING) - FMT_MAKE_STR_VALUE(const std::string &, STRING) - FMT_MAKE_STR_VALUE(StringRef, STRING) + FMT_MAKE_VALUE(char *, string.value, CSTRING) + FMT_MAKE_VALUE(const char *, string.value, CSTRING) + FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING) + FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING) + FMT_MAKE_STR_VALUE(const std::string &, STRING) + FMT_MAKE_STR_VALUE(StringRef, STRING) #define FMT_MAKE_WSTR_VALUE(Type, TYPE) \ MakeValue(typename WCharHelper::Supported value) { \ set_string(value); \ - } \ + } \ static uint64_t type(Type) { return Arg::TYPE; } - FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING) - FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING) - FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING) - FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING) + FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING) + FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING) + FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING) + FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING) - FMT_MAKE_VALUE(void *, pointer, POINTER) - FMT_MAKE_VALUE(const void *, pointer, POINTER) + FMT_MAKE_VALUE(void *, pointer, POINTER) + FMT_MAKE_VALUE(const void *, pointer, POINTER) - template - MakeValue(const T &value) - { - custom.value = &value; - custom.format = &format_custom_arg; - } - template - static uint64_t type(const T &) - { - return Arg::CUSTOM; - } + template + MakeValue(const T &value, + typename EnableIf::value, int>::type = 0) { + custom.value = &value; + custom.format = &format_custom_arg; + } + + template + MakeValue(const T &value, + typename EnableIf::value, int>::type = 0) { + int_value = value; + } + + template + static uint64_t type(const T &) { + return IsConvertibleToInt::value ? Arg::INT : Arg::CUSTOM; + } }; #define FMT_DISPATCH(call) static_cast(this)->call @@ -1072,256 +976,254 @@ public: // ArgVisitor uses the curiously recurring template pattern: // http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern template -class ArgVisitor -{ -public: - Result visit_unhandled_arg() - { - return Result(); - } +class ArgVisitor { + public: + void report_unhandled_arg() {} - Result visit_int(int value) - { - return FMT_DISPATCH(visit_any_int(value)); - } - Result visit_long_long(LongLong value) - { - return FMT_DISPATCH(visit_any_int(value)); - } - Result visit_uint(unsigned value) - { - return FMT_DISPATCH(visit_any_int(value)); - } - Result visit_ulong_long(ULongLong value) - { - return FMT_DISPATCH(visit_any_int(value)); - } - Result visit_char(int value) - { - return FMT_DISPATCH(visit_any_int(value)); - } - template - Result visit_any_int(T) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } + Result visit_unhandled_arg() { + FMT_DISPATCH(report_unhandled_arg()); + return Result(); + } - Result visit_double(double value) - { - return FMT_DISPATCH(visit_any_double(value)); - } - Result visit_long_double(long double value) - { - return FMT_DISPATCH(visit_any_double(value)); - } - template - Result visit_any_double(T) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } + Result visit_int(int value) { + return FMT_DISPATCH(visit_any_int(value)); + } + Result visit_long_long(LongLong value) { + return FMT_DISPATCH(visit_any_int(value)); + } + Result visit_uint(unsigned value) { + return FMT_DISPATCH(visit_any_int(value)); + } + Result visit_ulong_long(ULongLong value) { + return FMT_DISPATCH(visit_any_int(value)); + } + Result visit_char(int value) { + return FMT_DISPATCH(visit_any_int(value)); + } + template + Result visit_any_int(T) { + return FMT_DISPATCH(visit_unhandled_arg()); + } - Result visit_string(Arg::StringValue) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } - Result visit_wstring(Arg::StringValue) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } - Result visit_pointer(const void *) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } - Result visit_custom(Arg::CustomValue) - { - return FMT_DISPATCH(visit_unhandled_arg()); - } + Result visit_double(double value) { + return FMT_DISPATCH(visit_any_double(value)); + } + Result visit_long_double(long double value) { + return FMT_DISPATCH(visit_any_double(value)); + } + template + Result visit_any_double(T) { + return FMT_DISPATCH(visit_unhandled_arg()); + } - Result visit(const Arg &arg) - { - switch (arg.type) - { - default: - assert(false); - return Result(); - case Arg::INT: - return FMT_DISPATCH(visit_int(arg.int_value)); - case Arg::UINT: - return FMT_DISPATCH(visit_uint(arg.uint_value)); - case Arg::LONG_LONG: - return FMT_DISPATCH(visit_long_long(arg.long_long_value)); - case Arg::ULONG_LONG: - return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value)); - case Arg::DOUBLE: - return FMT_DISPATCH(visit_double(arg.double_value)); - case Arg::LONG_DOUBLE: - return FMT_DISPATCH(visit_long_double(arg.long_double_value)); - case Arg::CHAR: - return FMT_DISPATCH(visit_char(arg.int_value)); - case Arg::CSTRING: - { - Value::StringValue str = arg.string; - str.size = 0; - return FMT_DISPATCH(visit_string(str)); - } - case Arg::STRING: - return FMT_DISPATCH(visit_string(arg.string)); - case Arg::WSTRING: - return FMT_DISPATCH(visit_wstring(arg.wstring)); - case Arg::POINTER: - return FMT_DISPATCH(visit_pointer(arg.pointer)); - case Arg::CUSTOM: - return FMT_DISPATCH(visit_custom(arg.custom)); - } + Result visit_string(Arg::StringValue) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + Result visit_wstring(Arg::StringValue) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + Result visit_pointer(const void *) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + Result visit_custom(Arg::CustomValue) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + Result visit(const Arg &arg) { + switch (arg.type) { + default: + assert(false); + return Result(); + case Arg::INT: + return FMT_DISPATCH(visit_int(arg.int_value)); + case Arg::UINT: + return FMT_DISPATCH(visit_uint(arg.uint_value)); + case Arg::LONG_LONG: + return FMT_DISPATCH(visit_long_long(arg.long_long_value)); + case Arg::ULONG_LONG: + return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value)); + case Arg::DOUBLE: + return FMT_DISPATCH(visit_double(arg.double_value)); + case Arg::LONG_DOUBLE: + return FMT_DISPATCH(visit_long_double(arg.long_double_value)); + case Arg::CHAR: + return FMT_DISPATCH(visit_char(arg.int_value)); + case Arg::CSTRING: { + Arg::StringValue str = arg.string; + str.size = 0; + return FMT_DISPATCH(visit_string(str)); } + case Arg::STRING: + return FMT_DISPATCH(visit_string(arg.string)); + case Arg::WSTRING: + return FMT_DISPATCH(visit_wstring(arg.wstring)); + case Arg::POINTER: + return FMT_DISPATCH(visit_pointer(arg.pointer)); + case Arg::CUSTOM: + return FMT_DISPATCH(visit_custom(arg.custom)); + } + } }; -class RuntimeError : public std::runtime_error -{ -protected: - RuntimeError() : std::runtime_error("") {} +class RuntimeError : public std::runtime_error { + protected: + RuntimeError() : std::runtime_error("") {} }; template class ArgFormatter; } // namespace internal -/** -An argument list. -*/ -class ArgList -{ -private: - uint64_t types_; +/** An argument list. */ +class ArgList { + private: + // To reduce compiled code size per formatting function call, types of first + // MAX_PACKED_ARGS arguments are passed in the types_ field. + uint64_t types_; + union { + // If the number of arguments is less than MAX_PACKED_ARGS, the argument + // values are stored in values_, otherwise they are stored in args_. + // This is done to reduce compiled code size as storing larger objects + // may require more code (at least on x86-64) even if the same amount of + // data is actually copied to stack. It saves ~10% on the bloat test. const internal::Value *values_; + const internal::Arg *args_; + }; -public: - // Maximum number of arguments that can be passed in ArgList. - enum { MAX_ARGS = 16 }; + internal::Arg::Type type(unsigned index) const { + unsigned shift = index * 4; + uint64_t mask = 0xf; + return static_cast( + (types_ & (mask << shift)) >> shift); + } - ArgList() : types_(0) {} - ArgList(ULongLong types, const internal::Value *values) - : types_(types), values_(values) {} + public: + // Maximum number of arguments with packed types. + enum { MAX_PACKED_ARGS = 16 }; - /** - Returns the argument at specified index. - */ - internal::Arg operator[](unsigned index) const - { - using internal::Arg; - Arg arg; - if (index >= MAX_ARGS) - { - arg.type = Arg::NONE; - return arg; - } - unsigned shift = index * 4; - uint64_t mask = 0xf; - Arg::Type type = - static_cast((types_ & (mask << shift)) >> shift); - arg.type = type; - if (type != Arg::NONE) - { - internal::Value &value = arg; - value = values_[index]; - } - return arg; + ArgList() : types_(0) {} + + // TODO: MakeArgList(const Args &...) + ArgList(ULongLong types, const internal::Value *values) + : types_(types), values_(values) {} + ArgList(ULongLong types, const internal::Arg *args) + : types_(types), args_(args) {} + + /** Returns the argument at specified index. */ + internal::Arg operator[](unsigned index) const { + using internal::Arg; + Arg arg; + bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE; + if (index < MAX_PACKED_ARGS) { + Arg::Type arg_type = type(index); + internal::Value &val = arg; + if (arg_type != Arg::NONE) + val = use_values ? values_[index] : args_[index]; + arg.type = arg_type; + return arg; } + if (use_values) { + // The index is greater than the number of arguments that can be stored + // in values, so return a "none" argument. + arg.type = Arg::NONE; + return arg; + } + for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) { + if (args_[i].type == Arg::NONE) + return args_[i]; + } + return args_[index]; + } }; struct FormatSpec; -namespace internal -{ +namespace internal { -class FormatterBase -{ -private: - ArgList args_; - int next_arg_index_; +template +struct SelectValueType { + typedef typename Conditional< + (NUM_ARGS < ArgList::MAX_PACKED_ARGS), Value, Arg>::type Type; +}; - // Returns the argument with specified index. - Arg do_get_arg(unsigned arg_index, const char *&error); +class FormatterBase { + private: + ArgList args_; + int next_arg_index_; -protected: - void set_args(const ArgList &args) - { - args_ = args; - next_arg_index_ = 0; - } + // Returns the argument with specified index. + Arg do_get_arg(unsigned arg_index, const char *&error); - // Returns the next argument. - Arg next_arg(const char *&error); + protected: + void set_args(const ArgList &args) { + args_ = args; + next_arg_index_ = 0; + } - // Checks if manual indexing is used and returns the argument with - // specified index. - Arg get_arg(unsigned arg_index, const char *&error); + // Returns the next argument. + Arg next_arg(const char *&error); - template - void write(BasicWriter &w, const Char *start, const Char *end) - { - if (start != end) - w << BasicStringRef(start, end - start); - } + // Checks if manual indexing is used and returns the argument with + // specified index. + Arg get_arg(unsigned arg_index, const char *&error); + + template + void write(BasicWriter &w, const Char *start, const Char *end) { + if (start != end) + w << BasicStringRef(start, end - start); + } }; // A printf formatter. template -class PrintfFormatter : private FormatterBase -{ -private: - void parse_flags(FormatSpec &spec, const Char *&s); +class PrintfFormatter : private FormatterBase { + private: + void parse_flags(FormatSpec &spec, const Char *&s); - // Returns the argument with specified index or, if arg_index is equal - // to the maximum unsigned value, the next argument. - Arg get_arg(const Char *s, - unsigned arg_index = (std::numeric_limits::max)()); + // Returns the argument with specified index or, if arg_index is equal + // to the maximum unsigned value, the next argument. + Arg get_arg(const Char *s, + unsigned arg_index = (std::numeric_limits::max)()); - // Parses argument index, flags and width and returns the argument index. - unsigned parse_header(const Char *&s, FormatSpec &spec); + // Parses argument index, flags and width and returns the argument index. + unsigned parse_header(const Char *&s, FormatSpec &spec); -public: - void format(BasicWriter &writer, - BasicStringRef format_str, const ArgList &args); + public: + void format(BasicWriter &writer, + BasicStringRef format_str, const ArgList &args); }; } // namespace internal // A formatter. template -class BasicFormatter : private internal::FormatterBase -{ -private: - BasicWriter &writer_; - const Char *start_; +class BasicFormatter : private internal::FormatterBase { + private: + BasicWriter &writer_; + const Char *start_; + + FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter); - FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter); + // Parses argument index and returns corresponding argument. + internal::Arg parse_arg_index(const Char *&s); - // Parses argument index and returns corresponding argument. - internal::Arg parse_arg_index(const Char *&s); + public: + explicit BasicFormatter(BasicWriter &w) : writer_(w) {} -public: - explicit BasicFormatter(BasicWriter &w) : writer_(w) {} + BasicWriter &writer() { return writer_; } - BasicWriter &writer() - { - return writer_; - } + void format(BasicStringRef format_str, const ArgList &args); - void format(BasicStringRef format_str, const ArgList &args); - - const Char *format(const Char *&format_str, const internal::Arg &arg); + const Char *format(const Char *&format_str, const internal::Arg &arg); }; -enum Alignment -{ - ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC +enum Alignment { + ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC }; // Flags. -enum -{ - SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8, - CHAR_FLAG = 0x10 // Argument has char type - used in error reporting. +enum { + SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8, + CHAR_FLAG = 0x10 // Argument has char type - used in error reporting. }; // An empty format specifier. @@ -1329,184 +1231,126 @@ struct EmptySpec {}; // A type specifier. template -struct TypeSpec : EmptySpec -{ - Alignment align() const - { - return ALIGN_DEFAULT; - } - unsigned width() const - { - return 0; - } - int precision() const - { - return -1; - } - bool flag(unsigned) const - { - return false; - } - char type() const - { - return TYPE; - } - char fill() const - { - return ' '; - } +struct TypeSpec : EmptySpec { + Alignment align() const { return ALIGN_DEFAULT; } + unsigned width() const { return 0; } + int precision() const { return -1; } + bool flag(unsigned) const { return false; } + char type() const { return TYPE; } + char fill() const { return ' '; } }; // A width specifier. -struct WidthSpec -{ - unsigned width_; - // Fill is always wchar_t and cast to char if necessary to avoid having - // two specialization of WidthSpec and its subclasses. - wchar_t fill_; +struct WidthSpec { + unsigned width_; + // Fill is always wchar_t and cast to char if necessary to avoid having + // two specialization of WidthSpec and its subclasses. + wchar_t fill_; - WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {} + WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {} - unsigned width() const - { - return width_; - } - wchar_t fill() const - { - return fill_; - } + unsigned width() const { return width_; } + wchar_t fill() const { return fill_; } }; // An alignment specifier. -struct AlignSpec : WidthSpec -{ - Alignment align_; +struct AlignSpec : WidthSpec { + Alignment align_; - AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT) - : WidthSpec(width, fill), align_(align) {} + AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT) + : WidthSpec(width, fill), align_(align) {} - Alignment align() const - { - return align_; - } + Alignment align() const { return align_; } - int precision() const - { - return -1; - } + int precision() const { return -1; } }; // An alignment and type specifier. template -struct AlignTypeSpec : AlignSpec -{ - AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {} +struct AlignTypeSpec : AlignSpec { + AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {} - bool flag(unsigned) const - { - return false; - } - char type() const - { - return TYPE; - } + bool flag(unsigned) const { return false; } + char type() const { return TYPE; } }; // A full format specifier. -struct FormatSpec : AlignSpec -{ - unsigned flags_; - int precision_; - char type_; +struct FormatSpec : AlignSpec { + unsigned flags_; + int precision_; + char type_; - FormatSpec( - unsigned width = 0, char type = 0, wchar_t fill = ' ') - : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {} + FormatSpec( + unsigned width = 0, char type = 0, wchar_t fill = ' ') + : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {} - bool flag(unsigned f) const - { - return (flags_ & f) != 0; - } - int precision() const - { - return precision_; - } - char type() const - { - return type_; - } + bool flag(unsigned f) const { return (flags_ & f) != 0; } + int precision() const { return precision_; } + char type() const { return type_; } }; // An integer format specifier. template , typename Char = char> -class IntFormatSpec : public SpecT -{ -private: - T value_; +class IntFormatSpec : public SpecT { + private: + T value_; -public: - IntFormatSpec(T val, const SpecT &spec = SpecT()) - : SpecT(spec), value_(val) {} + public: + IntFormatSpec(T val, const SpecT &spec = SpecT()) + : SpecT(spec), value_(val) {} - T value() const - { - return value_; - } + T value() const { return value_; } }; // A string format specifier. template -class StrFormatSpec : public AlignSpec -{ -private: - const T *str_; +class StrFormatSpec : public AlignSpec { + private: + const T *str_; -public: - StrFormatSpec(const T *str, unsigned width, wchar_t fill) - : AlignSpec(width, fill), str_(str) {} + public: + StrFormatSpec(const T *str, unsigned width, wchar_t fill) + : AlignSpec(width, fill), str_(str) {} - const T *str() const - { - return str_; - } + const T *str() const { return str_; } }; /** -Returns an integer format specifier to format the value in base 2. -*/ + Returns an integer format specifier to format the value in base 2. + */ IntFormatSpec > bin(int value); /** -Returns an integer format specifier to format the value in base 8. -*/ + Returns an integer format specifier to format the value in base 8. + */ IntFormatSpec > oct(int value); /** -Returns an integer format specifier to format the value in base 16 using -lower-case letters for the digits above 9. -*/ + Returns an integer format specifier to format the value in base 16 using + lower-case letters for the digits above 9. + */ IntFormatSpec > hex(int value); /** -Returns an integer formatter format specifier to format in base 16 using -upper-case letters for the digits above 9. -*/ + Returns an integer formatter format specifier to format in base 16 using + upper-case letters for the digits above 9. + */ IntFormatSpec > hexu(int value); /** -\rst -Returns an integer format specifier to pad the formatted argument with the -fill character to the specified width using the default (right) numeric -alignment. + \rst + Returns an integer format specifier to pad the formatted argument with the + fill character to the specified width using the default (right) numeric + alignment. -**Example**:: + **Example**:: -MemoryWriter out; -out << pad(hex(0xcafe), 8, '0'); -// out.str() == "0000cafe" + MemoryWriter out; + out << pad(hex(0xcafe), 8, '0'); + // out.str() == "0000cafe" -\endrst -*/ + \endrst + */ template IntFormatSpec, Char> pad( int value, unsigned width, Char fill = ' '); @@ -1514,26 +1358,26 @@ IntFormatSpec, Char> pad( #define FMT_DEFINE_INT_FORMATTERS(TYPE) \ inline IntFormatSpec > bin(TYPE value) { \ return IntFormatSpec >(value, TypeSpec<'b'>()); \ - } \ +} \ \ inline IntFormatSpec > oct(TYPE value) { \ return IntFormatSpec >(value, TypeSpec<'o'>()); \ - } \ +} \ \ inline IntFormatSpec > hex(TYPE value) { \ return IntFormatSpec >(value, TypeSpec<'x'>()); \ - } \ +} \ \ inline IntFormatSpec > hexu(TYPE value) { \ return IntFormatSpec >(value, TypeSpec<'X'>()); \ - } \ +} \ \ template \ inline IntFormatSpec > pad( \ IntFormatSpec > f, unsigned width) { \ return IntFormatSpec >( \ f.value(), AlignTypeSpec(width, ' ')); \ - } \ +} \ \ /* For compatibility with older compilers we provide two overloads for pad, */ \ /* one that takes a fill character and one that doesn't. In the future this */ \ @@ -1545,20 +1389,20 @@ inline IntFormatSpec, Char> pad( \ unsigned width, Char fill) { \ return IntFormatSpec, Char>( \ f.value(), AlignTypeSpec(width, fill)); \ - } \ +} \ \ inline IntFormatSpec > pad( \ TYPE value, unsigned width) { \ return IntFormatSpec >( \ value, AlignTypeSpec<0>(width, ' ')); \ - } \ +} \ \ template \ inline IntFormatSpec, Char> pad( \ TYPE value, unsigned width, Char fill) { \ return IntFormatSpec, Char>( \ value, AlignTypeSpec<0>(width, fill)); \ - } +} FMT_DEFINE_INT_FORMATTERS(int) FMT_DEFINE_INT_FORMATTERS(long) @@ -1568,28 +1412,26 @@ FMT_DEFINE_INT_FORMATTERS(LongLong) FMT_DEFINE_INT_FORMATTERS(ULongLong) /** -\rst -Returns a string formatter that pads the formatted argument with the fill -character to the specified width using the default (left) string alignment. + \rst + Returns a string formatter that pads the formatted argument with the fill + character to the specified width using the default (left) string alignment. -**Example**:: + **Example**:: -std::string s = str(MemoryWriter() << pad("abc", 8)); -// s == "abc " + std::string s = str(MemoryWriter() << pad("abc", 8)); + // s == "abc " -\endrst -*/ + \endrst + */ template inline StrFormatSpec pad( - const Char *str, unsigned width, Char fill = ' ') -{ - return StrFormatSpec(str, width, fill); + const Char *str, unsigned width, Char fill = ' ') { + return StrFormatSpec(str, width, fill); } inline StrFormatSpec pad( - const wchar_t *str, unsigned width, char fill = ' ') -{ - return StrFormatSpec(str, width, fill); + const wchar_t *str, unsigned width, char fill = ' ') { + return StrFormatSpec(str, width, fill); } // Generates a comma-separated list with results of applying f to @@ -1611,45 +1453,35 @@ inline StrFormatSpec pad( # define FMT_GEN14(f) FMT_GEN13(f), f(13) # define FMT_GEN15(f) FMT_GEN14(f), f(14) -namespace internal -{ -inline uint64_t make_type() -{ - return 0; -} +namespace internal { +inline uint64_t make_type() { return 0; } template -inline uint64_t make_type(const T &arg) -{ - return MakeValue::type(arg); -} +inline uint64_t make_type(const T &arg) { return MakeValue::type(arg); } #if FMT_USE_VARIADIC_TEMPLATES template -inline uint64_t make_type(const Arg &first, const Args & ... tail) -{ - return make_type(first) | (make_type(tail...) << 4); +inline uint64_t make_type(const Arg &first, const Args & ... tail) { + return make_type(first) | (make_type(tail...) << 4); } #else -struct ArgType -{ - uint64_t type; +struct ArgType { + uint64_t type; - ArgType() : type(0) {} + ArgType() : type(0) {} - template - ArgType(const T &arg) : type(make_type(arg)) {} + template + ArgType(const T &arg) : type(make_type(arg)) {} }; # define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType() -inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) -{ - return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) | - (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) | - (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) | - (t12.type << 48) | (t13.type << 52) | (t14.type << 56); +inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { + return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) | + (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) | + (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) | + (t12.type << 48) | (t13.type << 52) | (t14.type << 56); } #endif } // namespace internal @@ -1664,25 +1496,26 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) // Defines a variadic function returning void. # define FMT_VARIADIC_VOID(func, arg_type) \ template \ - void func(arg_type arg1, const Args & ... args) { \ - const fmt::internal::Value values[ \ - fmt::internal::NonZero::VALUE] = { \ - fmt::internal::MakeValue(args)... \ - }; \ - func(arg1, ArgList(fmt::internal::make_type(args...), values)); \ - } + void func(arg_type arg0, const Args & ... args) { \ + namespace internal = fmt::internal; \ + typedef typename internal::SelectValueType::Type Value; \ + const Value array[internal::NonZero::VALUE] = { \ + internal::MakeValue(args)... \ + }; \ + func(arg0, ArgList(internal::make_type(args...), array)); \ + } // Defines a variadic constructor. # define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ template \ ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \ - using fmt::internal::MakeValue; \ - const fmt::internal::Value values[ \ - fmt::internal::NonZero::VALUE] = { \ - MakeValue(args)... \ - }; \ - func(arg0, arg1, ArgList(fmt::internal::make_type(args...), values)); \ - } + namespace internal = fmt::internal; \ + typedef typename internal::SelectValueType::Type Value; \ + const Value array[internal::NonZero::VALUE] = { \ + internal::MakeValue(args)... \ + }; \ + func(arg0, arg1, ArgList(internal::make_type(args...), array)); \ + } #else @@ -1694,10 +1527,10 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) # define FMT_WRAP1(func, arg_type, n) \ template \ inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \ - const fmt::internal::Value vals[] = {FMT_GEN(n, FMT_MAKE_REF)}; \ + const fmt::internal::Value values[] = {FMT_GEN(n, FMT_MAKE_REF)}; \ func(arg1, fmt::ArgList( \ - fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), vals)); \ - } + fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), values)); \ + } // Emulates a variadic function returning void on a pre-C++11 compiler. # define FMT_VARIADIC_VOID(func, arg_type) \ @@ -1711,10 +1544,10 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) # define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \ template \ ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \ - const fmt::internal::Value vals[] = {FMT_GEN(n, FMT_MAKE_REF)}; \ + const fmt::internal::Value values[] = {FMT_GEN(n, FMT_MAKE_REF)}; \ func(arg0, arg1, fmt::ArgList( \ - fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), vals)); \ - } + fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), values)); \ + } // Emulates a variadic constructor on a pre-C++11 compiler. # define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ @@ -1753,831 +1586,764 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9) /** -An error returned by an operating system or a language runtime, -for example a file opening error. + An error returned by an operating system or a language runtime, + for example a file opening error. */ -class SystemError : public internal::RuntimeError -{ -private: - void init(int err_code, StringRef format_str, ArgList args); +class SystemError : public internal::RuntimeError { + private: + void init(int err_code, StringRef format_str, ArgList args); -protected: - int error_code_; + protected: + int error_code_; - typedef char Char; // For FMT_VARIADIC_CTOR. + typedef char Char; // For FMT_VARIADIC_CTOR. - SystemError() {} + SystemError() {} -public: - /** - \rst - Constructs a :class:`fmt::SystemError` object with the description - of the form + public: + /** + \rst + Constructs a :class:`fmt::SystemError` object with the description + of the form - .. parsed-literal:: - **: ** + .. parsed-literal:: + **: ** - where ** is the formatted message and ** is - the system message corresponding to the error code. - *error_code* is a system error code as given by ``errno``. - If *error_code* is not a valid error code such as -1, the system message - may look like "Unknown error -1" and is platform-dependent. + where ** is the formatted message and ** is + the system message corresponding to the error code. + *error_code* is a system error code as given by ``errno``. + If *error_code* is not a valid error code such as -1, the system message + may look like "Unknown error -1" and is platform-dependent. + + **Example**:: - **Example**:: + // This throws a SystemError with the description + // cannot open file 'madeup': No such file or directory + // or similar (system message may vary). + const char *filename = "madeup"; + std::FILE *file = std::fopen(filename, "r"); + if (!file) + throw fmt::SystemError(errno, "cannot open file '{}'", filename); + \endrst + */ + SystemError(int error_code, StringRef message) { + init(error_code, message, ArgList()); + } + FMT_VARIADIC_CTOR(SystemError, init, int, StringRef) - // This throws a SystemError with the description - // cannot open file 'madeup': No such file or directory - // or similar (system message may vary). - const char *filename = "madeup"; - std::FILE *file = std::fopen(filename, "r"); - if (!file) - throw fmt::SystemError(errno, "cannot open file '{}'", filename); - \endrst - */ - SystemError(int error_code, StringRef message) - { - init(error_code, message, ArgList()); - } - FMT_VARIADIC_CTOR(SystemError, init, int, StringRef) - - int error_code() const - { - return error_code_; - } + int error_code() const { return error_code_; } }; /** -\rst -This template provides operations for formatting and writing data into -a character stream. The output is stored in a buffer provided by a subclass -such as :class:`fmt::BasicMemoryWriter`. + \rst + This template provides operations for formatting and writing data into + a character stream. The output is stored in a buffer provided by a subclass + such as :class:`fmt::BasicMemoryWriter`. -You can use one of the following typedefs for common character types: + You can use one of the following typedefs for common character types: -+---------+----------------------+ -| Type | Definition | -+=========+======================+ -| Writer | BasicWriter | -+---------+----------------------+ -| WWriter | BasicWriter | -+---------+----------------------+ + +---------+----------------------+ + | Type | Definition | + +=========+======================+ + | Writer | BasicWriter | + +---------+----------------------+ + | WWriter | BasicWriter | + +---------+----------------------+ -\endrst -*/ + \endrst + */ template -class BasicWriter -{ -private: - // Output buffer. - internal::Buffer &buffer_; +class BasicWriter { + private: + // Output buffer. + Buffer &buffer_; - FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter); + FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter); - typedef typename internal::CharTraits::CharPtr CharPtr; + typedef typename internal::CharTraits::CharPtr CharPtr; #if _SECURE_SCL - // Returns pointer value. - static Char *get(CharPtr p) - { - return p.base(); - } + // Returns pointer value. + static Char *get(CharPtr p) { return p.base(); } #else - static Char *get(Char *p) - { - return p; - } + static Char *get(Char *p) { return p; } #endif - // Fills the padding around the content and returns the pointer to the - // content area. - static CharPtr fill_padding(CharPtr buffer, - unsigned total_size, std::size_t content_size, wchar_t fill); + // Fills the padding around the content and returns the pointer to the + // content area. + static CharPtr fill_padding(CharPtr buffer, + unsigned total_size, std::size_t content_size, wchar_t fill); - // Grows the buffer by n characters and returns a pointer to the newly - // allocated area. - CharPtr grow_buffer(std::size_t n) - { - std::size_t size = buffer_.size(); - buffer_.resize(size + n); - return internal::make_ptr(&buffer_[size], n); - } + // Grows the buffer by n characters and returns a pointer to the newly + // allocated area. + CharPtr grow_buffer(std::size_t n) { + std::size_t size = buffer_.size(); + buffer_.resize(size + n); + return internal::make_ptr(&buffer_[size], n); + } - // Prepare a buffer for integer formatting. - CharPtr prepare_int_buffer(unsigned num_digits, - const EmptySpec &, const char *prefix, unsigned prefix_size) - { - unsigned size = prefix_size + num_digits; - CharPtr p = grow_buffer(size); - std::copy(prefix, prefix + prefix_size, p); - return p + size - 1; - } + // Prepare a buffer for integer formatting. + CharPtr prepare_int_buffer(unsigned num_digits, + const EmptySpec &, const char *prefix, unsigned prefix_size) { + unsigned size = prefix_size + num_digits; + CharPtr p = grow_buffer(size); + std::copy(prefix, prefix + prefix_size, p); + return p + size - 1; + } - template - CharPtr prepare_int_buffer(unsigned num_digits, - const Spec &spec, const char *prefix, unsigned prefix_size); + template + CharPtr prepare_int_buffer(unsigned num_digits, + const Spec &spec, const char *prefix, unsigned prefix_size); - // Formats an integer. - template - void write_int(T value, Spec spec); + // Formats an integer. + template + void write_int(T value, Spec spec); - // Formats a floating-point number (double or long double). - template - void write_double(T value, const FormatSpec &spec); + // Formats a floating-point number (double or long double). + template + void write_double(T value, const FormatSpec &spec); - // Writes a formatted string. - template - CharPtr write_str( - const StrChar *s, std::size_t size, const AlignSpec &spec); + // Writes a formatted string. + template + CharPtr write_str( + const StrChar *s, std::size_t size, const AlignSpec &spec); - template - void write_str( - const internal::Arg::StringValue &str, const FormatSpec &spec); + template + void write_str( + const internal::Arg::StringValue &str, const FormatSpec &spec); - // This following methods are private to disallow writing wide characters - // and strings to a char stream. If you want to print a wide string as a - // pointer as std::ostream does, cast it to const void*. - // Do not implement! - void operator<<(typename internal::WCharHelper::Unsupported); - void operator<<( - typename internal::WCharHelper::Unsupported); + // This following methods are private to disallow writing wide characters + // and strings to a char stream. If you want to print a wide string as a + // pointer as std::ostream does, cast it to const void*. + // Do not implement! + void operator<<(typename internal::WCharHelper::Unsupported); + void operator<<( + typename internal::WCharHelper::Unsupported); - // Appends floating-point length specifier to the format string. - // The second argument is only used for overload resolution. - void append_float_length(Char *&format_ptr, long double) - { - *format_ptr++ = 'L'; - } + // Appends floating-point length specifier to the format string. + // The second argument is only used for overload resolution. + void append_float_length(Char *&format_ptr, long double) { + *format_ptr++ = 'L'; + } - template - void append_float_length(Char *&, T) {} + template + void append_float_length(Char *&, T) {} - friend class internal::ArgFormatter; - friend class internal::PrintfFormatter; + friend class internal::ArgFormatter; + friend class internal::PrintfFormatter; -protected: - /** + protected: + /** Constructs a ``BasicWriter`` object. - */ - explicit BasicWriter(internal::Buffer &b) : buffer_(b) {} + */ + explicit BasicWriter(Buffer &b) : buffer_(b) {} -public: - /** + public: + /** Destroys a ``BasicWriter`` object. - */ - virtual ~BasicWriter() {} + */ + virtual ~BasicWriter() {} - /** + /** Returns the total number of characters written. - */ - std::size_t size() const - { - return buffer_.size(); - } + */ + std::size_t size() const { return buffer_.size(); } - /** + /** Returns a pointer to the output buffer content. No terminating null character is appended. - */ - const Char *data() const FMT_NOEXCEPT - { - return &buffer_[0]; - } + */ + const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; } - /** + /** Returns a pointer to the output buffer content with terminating null character appended. - */ - const Char *c_str() const - { - std::size_t size = buffer_.size(); - buffer_.reserve(size + 1); - buffer_[size] = '\0'; - return &buffer_[0]; - } + */ + const Char *c_str() const { + std::size_t size = buffer_.size(); + buffer_.reserve(size + 1); + buffer_[size] = '\0'; + return &buffer_[0]; + } - /** + /** Returns the content of the output buffer as an `std::string`. - */ - std::basic_string str() const - { - return std::basic_string(&buffer_[0], buffer_.size()); - } + */ + std::basic_string str() const { + return std::basic_string(&buffer_[0], buffer_.size()); + } - /** + /** \rst Writes formatted data. - + *args* is an argument list representing arbitrary arguments. **Example**:: - MemoryWriter out; - out.write("Current point:\n"); - out.write("({:+f}, {:+f})", -3.14, 3.14); + MemoryWriter out; + out.write("Current point:\n"); + out.write("({:+f}, {:+f})", -3.14, 3.14); This will write the following output to the ``out`` object: .. code-block:: none - Current point: - (-3.140000, +3.140000) + Current point: + (-3.140000, +3.140000) The output can be accessed using :func:`data()`, :func:`c_str` or :func:`str` methods. See also :ref:`syntax`. \endrst - */ - void write(BasicStringRef format, ArgList args) - { - BasicFormatter(*this).format(format, args); - } - FMT_VARIADIC_VOID(write, BasicStringRef) + */ + void write(BasicStringRef format, ArgList args) { + BasicFormatter(*this).format(format, args); + } + FMT_VARIADIC_VOID(write, BasicStringRef) - BasicWriter &operator<<(int value) - { - return *this << IntFormatSpec(value); - } - BasicWriter &operator<<(unsigned value) - { - return *this << IntFormatSpec(value); - } - BasicWriter &operator<<(long value) - { - return *this << IntFormatSpec(value); - } - BasicWriter &operator<<(unsigned long value) - { - return *this << IntFormatSpec(value); - } - BasicWriter &operator<<(LongLong value) - { - return *this << IntFormatSpec(value); - } + BasicWriter &operator<<(int value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(unsigned value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(long value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(unsigned long value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(LongLong value) { + return *this << IntFormatSpec(value); + } - /** + /** Formats *value* and writes it to the stream. - */ - BasicWriter &operator<<(ULongLong value) - { - return *this << IntFormatSpec(value); - } + */ + BasicWriter &operator<<(ULongLong value) { + return *this << IntFormatSpec(value); + } - BasicWriter &operator<<(double value) - { - write_double(value, FormatSpec()); - return *this; - } + BasicWriter &operator<<(double value) { + write_double(value, FormatSpec()); + return *this; + } - /** + /** Formats *value* using the general format for floating-point numbers (``'g'``) and writes it to the stream. - */ - BasicWriter &operator<<(long double value) - { - write_double(value, FormatSpec()); - return *this; - } + */ + BasicWriter &operator<<(long double value) { + write_double(value, FormatSpec()); + return *this; + } - /** + /** Writes a character to the stream. - */ - BasicWriter &operator<<(char value) - { - buffer_.push_back(value); - return *this; - } + */ + BasicWriter &operator<<(char value) { + buffer_.push_back(value); + return *this; + } - BasicWriter &operator<<( - typename internal::WCharHelper::Supported value) - { - buffer_.push_back(value); - return *this; - } + BasicWriter &operator<<( + typename internal::WCharHelper::Supported value) { + buffer_.push_back(value); + return *this; + } - /** + /** Writes *value* to the stream. - */ - BasicWriter &operator<<(fmt::BasicStringRef value) - { - const Char *str = value.c_str(); - buffer_.append(str, str + value.size()); - return *this; - } + */ + BasicWriter &operator<<(fmt::BasicStringRef value) { + const Char *str = value.c_str(); + buffer_.append(str, str + value.size()); + return *this; + } - template - BasicWriter &operator<<(IntFormatSpec spec) - { - internal::CharTraits::convert(FillChar()); - write_int(spec.value(), spec); - return *this; - } + template + BasicWriter &operator<<(IntFormatSpec spec) { + internal::CharTraits::convert(FillChar()); + write_int(spec.value(), spec); + return *this; + } - template - BasicWriter &operator<<(const StrFormatSpec &spec) - { - const StrChar *s = spec.str(); - // TODO: error if fill is not convertible to Char - write_str(s, std::char_traits::length(s), spec); - return *this; - } + template + BasicWriter &operator<<(const StrFormatSpec &spec) { + const StrChar *s = spec.str(); + // TODO: error if fill is not convertible to Char + write_str(s, std::char_traits::length(s), spec); + return *this; + } - void clear() FMT_NOEXCEPT { buffer_.clear(); } + void clear() FMT_NOEXCEPT { buffer_.clear(); } }; template template typename BasicWriter::CharPtr BasicWriter::write_str( - const StrChar *s, std::size_t size, const AlignSpec &spec) -{ - CharPtr out = CharPtr(); - if (spec.width() > size) - { - out = grow_buffer(spec.width()); - Char fill = static_cast(spec.fill()); - if (spec.align() == ALIGN_RIGHT) - { - std::fill_n(out, spec.width() - size, fill); - out += spec.width() - size; - } - else if (spec.align() == ALIGN_CENTER) - { - out = fill_padding(out, spec.width(), size, fill); - } - else - { - std::fill_n(out + size, spec.width() - size, fill); - } + const StrChar *s, std::size_t size, const AlignSpec &spec) { + CharPtr out = CharPtr(); + if (spec.width() > size) { + out = grow_buffer(spec.width()); + Char fill = static_cast(spec.fill()); + if (spec.align() == ALIGN_RIGHT) { + std::fill_n(out, spec.width() - size, fill); + out += spec.width() - size; + } else if (spec.align() == ALIGN_CENTER) { + out = fill_padding(out, spec.width(), size, fill); + } else { + std::fill_n(out + size, spec.width() - size, fill); } - else - { - out = grow_buffer(size); - } - std::copy(s, s + size, out); - return out; + } else { + out = grow_buffer(size); + } + std::copy(s, s + size, out); + return out; } template typename BasicWriter::CharPtr -BasicWriter::fill_padding( + BasicWriter::fill_padding( CharPtr buffer, unsigned total_size, - std::size_t content_size, wchar_t fill) -{ - std::size_t padding = total_size - content_size; - std::size_t left_padding = padding / 2; - Char fill_char = static_cast(fill); - std::fill_n(buffer, left_padding, fill_char); - buffer += left_padding; - CharPtr content = buffer; - std::fill_n(buffer + content_size, padding - left_padding, fill_char); - return content; + std::size_t content_size, wchar_t fill) { + std::size_t padding = total_size - content_size; + std::size_t left_padding = padding / 2; + Char fill_char = static_cast(fill); + std::fill_n(buffer, left_padding, fill_char); + buffer += left_padding; + CharPtr content = buffer; + std::fill_n(buffer + content_size, padding - left_padding, fill_char); + return content; } template template typename BasicWriter::CharPtr -BasicWriter::prepare_int_buffer( + BasicWriter::prepare_int_buffer( unsigned num_digits, const Spec &spec, - const char *prefix, unsigned prefix_size) -{ - unsigned width = spec.width(); - Alignment align = spec.align(); - Char fill = static_cast(spec.fill()); - if (spec.precision() > static_cast(num_digits)) - { - // Octal prefix '0' is counted as a digit, so ignore it if precision - // is specified. - if (prefix_size > 0 && prefix[prefix_size - 1] == '0') - --prefix_size; - unsigned number_size = prefix_size + spec.precision(); - AlignSpec subspec(number_size, '0', ALIGN_NUMERIC); - if (number_size >= width) - return prepare_int_buffer(num_digits, subspec, prefix, prefix_size); - buffer_.reserve(width); - unsigned fill_size = width - number_size; - if (align != ALIGN_LEFT) - { - CharPtr p = grow_buffer(fill_size); - std::fill(p, p + fill_size, fill); - } - CharPtr result = prepare_int_buffer( - num_digits, subspec, prefix, prefix_size); - if (align == ALIGN_LEFT) - { - CharPtr p = grow_buffer(fill_size); - std::fill(p, p + fill_size, fill); - } - return result; + const char *prefix, unsigned prefix_size) { + unsigned width = spec.width(); + Alignment align = spec.align(); + Char fill = static_cast(spec.fill()); + if (spec.precision() > static_cast(num_digits)) { + // Octal prefix '0' is counted as a digit, so ignore it if precision + // is specified. + if (prefix_size > 0 && prefix[prefix_size - 1] == '0') + --prefix_size; + unsigned number_size = prefix_size + spec.precision(); + AlignSpec subspec(number_size, '0', ALIGN_NUMERIC); + if (number_size >= width) + return prepare_int_buffer(num_digits, subspec, prefix, prefix_size); + buffer_.reserve(width); + unsigned fill_size = width - number_size; + if (align != ALIGN_LEFT) { + CharPtr p = grow_buffer(fill_size); + std::fill(p, p + fill_size, fill); } - unsigned size = prefix_size + num_digits; - if (width <= size) - { - CharPtr p = grow_buffer(size); - std::copy(prefix, prefix + prefix_size, p); - return p + size - 1; + CharPtr result = prepare_int_buffer( + num_digits, subspec, prefix, prefix_size); + if (align == ALIGN_LEFT) { + CharPtr p = grow_buffer(fill_size); + std::fill(p, p + fill_size, fill); } - CharPtr p = grow_buffer(width); - CharPtr end = p + width; - if (align == ALIGN_LEFT) - { - std::copy(prefix, prefix + prefix_size, p); - p += size; - std::fill(p, end, fill); + return result; + } + unsigned size = prefix_size + num_digits; + if (width <= size) { + CharPtr p = grow_buffer(size); + std::copy(prefix, prefix + prefix_size, p); + return p + size - 1; + } + CharPtr p = grow_buffer(width); + CharPtr end = p + width; + if (align == ALIGN_LEFT) { + std::copy(prefix, prefix + prefix_size, p); + p += size; + std::fill(p, end, fill); + } else if (align == ALIGN_CENTER) { + p = fill_padding(p, width, size, fill); + std::copy(prefix, prefix + prefix_size, p); + p += size; + } else { + if (align == ALIGN_NUMERIC) { + if (prefix_size != 0) { + p = std::copy(prefix, prefix + prefix_size, p); + size -= prefix_size; + } + } else { + std::copy(prefix, prefix + prefix_size, end - size); } - else if (align == ALIGN_CENTER) - { - p = fill_padding(p, width, size, fill); - std::copy(prefix, prefix + prefix_size, p); - p += size; - } - else - { - if (align == ALIGN_NUMERIC) - { - if (prefix_size != 0) - { - p = std::copy(prefix, prefix + prefix_size, p); - size -= prefix_size; - } - } - else - { - std::copy(prefix, prefix + prefix_size, end - size); - } - std::fill(p, end - size, fill); - p = end; - } - return p - 1; + std::fill(p, end - size, fill); + p = end; + } + return p - 1; } template template -void BasicWriter::write_int(T value, Spec spec) -{ - unsigned prefix_size = 0; - typedef typename internal::IntTraits::MainType UnsignedType; - UnsignedType abs_value = value; - char prefix[4] = ""; - if (internal::is_negative(value)) - { - prefix[0] = '-'; - ++prefix_size; - abs_value = 0 - abs_value; +void BasicWriter::write_int(T value, Spec spec) { + unsigned prefix_size = 0; + typedef typename internal::IntTraits::MainType UnsignedType; + UnsignedType abs_value = value; + char prefix[4] = ""; + if (internal::is_negative(value)) { + prefix[0] = '-'; + ++prefix_size; + abs_value = 0 - abs_value; + } else if (spec.flag(SIGN_FLAG)) { + prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' '; + ++prefix_size; + } + switch (spec.type()) { + case 0: case 'd': { + unsigned num_digits = internal::count_digits(abs_value); + CharPtr p = prepare_int_buffer( + num_digits, spec, prefix, prefix_size) + 1 - num_digits; + internal::format_decimal(get(p), abs_value, num_digits); + break; + } + case 'x': case 'X': { + UnsignedType n = abs_value; + if (spec.flag(HASH_FLAG)) { + prefix[prefix_size++] = '0'; + prefix[prefix_size++] = spec.type(); } - else if (spec.flag(SIGN_FLAG)) - { - prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' '; - ++prefix_size; - } - switch (spec.type()) - { - case 0: - case 'd': - { - unsigned num_digits = internal::count_digits(abs_value); - CharPtr p = prepare_int_buffer( - num_digits, spec, prefix, prefix_size) + 1 - num_digits; - internal::format_decimal(get(p), abs_value, num_digits); - break; - } - case 'x': - case 'X': - { - UnsignedType n = abs_value; - if (spec.flag(HASH_FLAG)) - { - prefix[prefix_size++] = '0'; - prefix[prefix_size++] = spec.type(); - } - unsigned num_digits = 0; - do - { - ++num_digits; - } - while ((n >>= 4) != 0); - Char *p = get(prepare_int_buffer( - num_digits, spec, prefix, prefix_size)); - n = abs_value; - const char *digits = spec.type() == 'x' ? - "0123456789abcdef" : "0123456789ABCDEF"; - do - { - *p-- = digits[n & 0xf]; - } - while ((n >>= 4) != 0); - break; - } - case 'b': - case 'B': - { - UnsignedType n = abs_value; - if (spec.flag(HASH_FLAG)) - { - prefix[prefix_size++] = '0'; - prefix[prefix_size++] = spec.type(); - } - unsigned num_digits = 0; - do - { - ++num_digits; - } - while ((n >>= 1) != 0); - Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); - n = abs_value; - do - { - *p-- = '0' + (n & 1); - } - while ((n >>= 1) != 0); - break; - } - case 'o': - { - UnsignedType n = abs_value; - if (spec.flag(HASH_FLAG)) - prefix[prefix_size++] = '0'; - unsigned num_digits = 0; - do - { - ++num_digits; - } - while ((n >>= 3) != 0); - Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); - n = abs_value; - do - { - *p-- = '0' + (n & 7); - } - while ((n >>= 3) != 0); - break; - } - default: - internal::report_unknown_type( - spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer"); - break; + unsigned num_digits = 0; + do { + ++num_digits; + } while ((n >>= 4) != 0); + Char *p = get(prepare_int_buffer( + num_digits, spec, prefix, prefix_size)); + n = abs_value; + const char *digits = spec.type() == 'x' ? + "0123456789abcdef" : "0123456789ABCDEF"; + do { + *p-- = digits[n & 0xf]; + } while ((n >>= 4) != 0); + break; + } + case 'b': case 'B': { + UnsignedType n = abs_value; + if (spec.flag(HASH_FLAG)) { + prefix[prefix_size++] = '0'; + prefix[prefix_size++] = spec.type(); } + unsigned num_digits = 0; + do { + ++num_digits; + } while ((n >>= 1) != 0); + Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); + n = abs_value; + do { + *p-- = '0' + (n & 1); + } while ((n >>= 1) != 0); + break; + } + case 'o': { + UnsignedType n = abs_value; + if (spec.flag(HASH_FLAG)) + prefix[prefix_size++] = '0'; + unsigned num_digits = 0; + do { + ++num_digits; + } while ((n >>= 3) != 0); + Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); + n = abs_value; + do { + *p-- = '0' + (n & 7); + } while ((n >>= 3) != 0); + break; + } + default: + internal::report_unknown_type( + spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer"); + break; + } } template template void BasicWriter::write_double( - T value, const FormatSpec &spec) -{ - // Check type. - char type = spec.type(); - bool upper = false; - switch (type) - { - case 0: - type = 'g'; - break; - case 'e': - case 'f': - case 'g': - case 'a': - break; - case 'F': + T value, const FormatSpec &spec) { + // Check type. + char type = spec.type(); + bool upper = false; + switch (type) { + case 0: + type = 'g'; + break; + case 'e': case 'f': case 'g': case 'a': + break; + case 'F': #ifdef _MSC_VER - // MSVC's printf doesn't support 'F'. - type = 'f'; + // MSVC's printf doesn't support 'F'. + type = 'f'; #endif - // Fall through. - case 'E': - case 'G': - case 'A': - upper = true; - break; - default: - internal::report_unknown_type(type, "double"); - break; - } + // Fall through. + case 'E': case 'G': case 'A': + upper = true; + break; + default: + internal::report_unknown_type(type, "double"); + break; + } - char sign = 0; - // Use getsign instead of value < 0 because the latter is always - // false for NaN. - if (internal::getsign(static_cast(value))) - { - sign = '-'; - value = -value; - } - else if (spec.flag(SIGN_FLAG)) - { - sign = spec.flag(PLUS_FLAG) ? '+' : ' '; - } + char sign = 0; + // Use getsign instead of value < 0 because the latter is always + // false for NaN. + if (internal::getsign(static_cast(value))) { + sign = '-'; + value = -value; + } else if (spec.flag(SIGN_FLAG)) { + sign = spec.flag(PLUS_FLAG) ? '+' : ' '; + } - if (value != value) - { - // Format NaN ourselves because sprintf's output is not consistent - // across platforms. - std::size_t nan_size = 4; - const char *nan = upper ? " NAN" : " nan"; - if (!sign) - { - --nan_size; - ++nan; - } - CharPtr out = write_str(nan, nan_size, spec); - if (sign) - *out = sign; - return; + if (value != value) { + // Format NaN ourselves because sprintf's output is not consistent + // across platforms. + std::size_t nan_size = 4; + const char *nan = upper ? " NAN" : " nan"; + if (!sign) { + --nan_size; + ++nan; } - - if (internal::isinfinity(value)) - { - // Format infinity ourselves because sprintf's output is not consistent - // across platforms. - std::size_t inf_size = 4; - const char *inf = upper ? " INF" : " inf"; - if (!sign) - { - --inf_size; - ++inf; - } - CharPtr out = write_str(inf, inf_size, spec); - if (sign) - *out = sign; - return; - } - - std::size_t offset = buffer_.size(); - unsigned width = spec.width(); + CharPtr out = write_str(nan, nan_size, spec); if (sign) - { - buffer_.reserve(buffer_.size() + (std::max)(width, 1u)); - if (width > 0) - --width; - ++offset; - } + *out = sign; + return; + } - // Build format string. - enum { MAX_FORMAT_SIZE = 10 }; // longest format: %#-*.*Lg - Char format[MAX_FORMAT_SIZE]; - Char *format_ptr = format; - *format_ptr++ = '%'; - unsigned width_for_sprintf = width; - if (spec.flag(HASH_FLAG)) - *format_ptr++ = '#'; - if (spec.align() == ALIGN_CENTER) - { - width_for_sprintf = 0; - } - else - { - if (spec.align() == ALIGN_LEFT) - *format_ptr++ = '-'; - if (width != 0) - *format_ptr++ = '*'; - } - if (spec.precision() >= 0) - { - *format_ptr++ = '.'; - *format_ptr++ = '*'; + if (internal::isinfinity(value)) { + // Format infinity ourselves because sprintf's output is not consistent + // across platforms. + std::size_t inf_size = 4; + const char *inf = upper ? " INF" : " inf"; + if (!sign) { + --inf_size; + ++inf; } + CharPtr out = write_str(inf, inf_size, spec); + if (sign) + *out = sign; + return; + } - append_float_length(format_ptr, value); - *format_ptr++ = type; - *format_ptr = '\0'; + std::size_t offset = buffer_.size(); + unsigned width = spec.width(); + if (sign) { + buffer_.reserve(buffer_.size() + (std::max)(width, 1u)); + if (width > 0) + --width; + ++offset; + } - // Format using snprintf. - Char fill = static_cast(spec.fill()); - for (;;) - { - std::size_t buffer_size = buffer_.capacity() - offset; + // Build format string. + enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg + Char format[MAX_FORMAT_SIZE]; + Char *format_ptr = format; + *format_ptr++ = '%'; + unsigned width_for_sprintf = width; + if (spec.flag(HASH_FLAG)) + *format_ptr++ = '#'; + if (spec.align() == ALIGN_CENTER) { + width_for_sprintf = 0; + } else { + if (spec.align() == ALIGN_LEFT) + *format_ptr++ = '-'; + if (width != 0) + *format_ptr++ = '*'; + } + if (spec.precision() >= 0) { + *format_ptr++ = '.'; + *format_ptr++ = '*'; + } + + append_float_length(format_ptr, value); + *format_ptr++ = type; + *format_ptr = '\0'; + + // Format using snprintf. + Char fill = static_cast(spec.fill()); + for (;;) { + std::size_t buffer_size = buffer_.capacity() - offset; #if _MSC_VER - // MSVC's vsnprintf_s doesn't work with zero size, so reserve - // space for at least one extra character to make the size non-zero. - // Note that the buffer's capacity will increase by more than 1. - if (buffer_size == 0) - { - buffer_.reserve(offset + 1); - buffer_size = buffer_.capacity() - offset; - } -#endif - Char *start = &buffer_[offset]; - int n = internal::CharTraits::format_float( - start, buffer_size, format, width_for_sprintf, spec.precision(), value); - if (n >= 0 && offset + n < buffer_.capacity()) - { - if (sign) - { - if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) || - *start != ' ') - { - *(start - 1) = sign; - sign = 0; - } - else - { - *(start - 1) = fill; - } - ++n; - } - if (spec.align() == ALIGN_CENTER && - spec.width() > static_cast(n)) - { - width = spec.width(); - CharPtr p = grow_buffer(width); - std::copy(p, p + n, p + (width - n) / 2); - fill_padding(p, spec.width(), n, fill); - return; - } - if (spec.fill() != ' ' || sign) - { - while (*start == ' ') - *start++ = fill; - if (sign) - *(start - 1) = sign; - } - grow_buffer(n); - return; - } - // If n is negative we ask to increase the capacity by at least 1, - // but as std::vector, the buffer grows exponentially. - buffer_.reserve(n >= 0 ? offset + n + 1 : buffer_.capacity() + 1); + // MSVC's vsnprintf_s doesn't work with zero size, so reserve + // space for at least one extra character to make the size non-zero. + // Note that the buffer's capacity will increase by more than 1. + if (buffer_size == 0) { + buffer_.reserve(offset + 1); + buffer_size = buffer_.capacity() - offset; } +#endif + Char *start = &buffer_[offset]; + int n = internal::CharTraits::format_float( + start, buffer_size, format, width_for_sprintf, spec.precision(), value); + if (n >= 0 && offset + n < buffer_.capacity()) { + if (sign) { + if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) || + *start != ' ') { + *(start - 1) = sign; + sign = 0; + } else { + *(start - 1) = fill; + } + ++n; + } + if (spec.align() == ALIGN_CENTER && + spec.width() > static_cast(n)) { + width = spec.width(); + CharPtr p = grow_buffer(width); + std::copy(p, p + n, p + (width - n) / 2); + fill_padding(p, spec.width(), n, fill); + return; + } + if (spec.fill() != ' ' || sign) { + while (*start == ' ') + *start++ = fill; + if (sign) + *(start - 1) = sign; + } + grow_buffer(n); + return; + } + // If n is negative we ask to increase the capacity by at least 1, + // but as std::vector, the buffer grows exponentially. + buffer_.reserve(n >= 0 ? offset + n + 1 : buffer_.capacity() + 1); + } } /** -\rst -This template provides operations for formatting and writing data into -a character stream. The output is stored in a memory buffer that grows -dynamically. + \rst + This class template provides operations for formatting and writing data + into a character stream. The output is stored in a memory buffer that grows + dynamically. -You can use one of the following typedefs for common character types -and the standard allocator: + You can use one of the following typedefs for common character types + and the standard allocator: -+---------------+-----------------------------------------------+ -| Type | Definition | -+===============+===============================================+ -| MemoryWriter | BasicWriter> | -+---------------+-----------------------------------------------+ -| WMemoryWriter | BasicWriter> | -+---------------+-----------------------------------------------+ + +---------------+-----------------------------------------------------+ + | Type | Definition | + +===============+=====================================================+ + | MemoryWriter | BasicMemoryWriter> | + +---------------+-----------------------------------------------------+ + | WMemoryWriter | BasicMemoryWriter> | + +---------------+-----------------------------------------------------+ -**Example**:: + **Example**:: -MemoryWriter out; -out << "The answer is " << 42 << "\n"; -out.write("({:+f}, {:+f})", -3.14, 3.14); + MemoryWriter out; + out << "The answer is " << 42 << "\n"; + out.write("({:+f}, {:+f})", -3.14, 3.14); -This will write the following output to the ``out`` object: + This will write the following output to the ``out`` object: -.. code-block:: none + .. code-block:: none -The answer is 42 -(-3.140000, +3.140000) + The answer is 42 + (-3.140000, +3.140000) -The output can be converted to an ``std::string`` with ``out.str()`` or -accessed as a C string with ``out.c_str()``. -\endrst -*/ + The output can be converted to an ``std::string`` with ``out.str()`` or + accessed as a C string with ``out.c_str()``. + \endrst + */ template > -class BasicMemoryWriter : public BasicWriter -{ -private: - internal::MemoryBuffer buffer_; +class BasicMemoryWriter : public BasicWriter { + private: + internal::MemoryBuffer buffer_; -public: - explicit BasicMemoryWriter(const Allocator& alloc = Allocator()) - : BasicWriter(buffer_), buffer_(alloc) {} + public: + explicit BasicMemoryWriter(const Allocator& alloc = Allocator()) + : BasicWriter(buffer_), buffer_(alloc) {} #if FMT_USE_RVALUE_REFERENCES - /** + /** + \rst Constructs a :class:`fmt::BasicMemoryWriter` object moving the content of the other object to it. - */ - BasicMemoryWriter(BasicMemoryWriter &&other) - : BasicWriter(buffer_), buffer_(std::move(other.buffer_)) - { - } + \endrst + */ + BasicMemoryWriter(BasicMemoryWriter &&other) + : BasicWriter(buffer_), buffer_(std::move(other.buffer_)) { + } - /** + /** + \rst Moves the content of the other ``BasicMemoryWriter`` object to this one. - */ - BasicMemoryWriter &operator=(BasicMemoryWriter &&other) - { - buffer_ = std::move(other.buffer_); - return *this; - } + \endrst + */ + BasicMemoryWriter &operator=(BasicMemoryWriter &&other) { + buffer_ = std::move(other.buffer_); + return *this; + } #endif }; typedef BasicMemoryWriter MemoryWriter; typedef BasicMemoryWriter WMemoryWriter; +/** + \rst + This class template provides operations for formatting and writing data + into a fixed-size array. For writing into a dynamically growing buffer + use :class:`fmt::BasicMemoryWriter`. + + Any write method will throw ``std::runtime_error`` if the output doesn't fit + into the array. + + You can use one of the following typedefs for common character types: + + +--------------+---------------------------+ + | Type | Definition | + +==============+===========================+ + | ArrayWriter | BasicArrayWriter | + +--------------+---------------------------+ + | WArrayWriter | BasicArrayWriter | + +--------------+---------------------------+ + \endrst + */ +template +class BasicArrayWriter : public BasicWriter { + private: + internal::FixedBuffer buffer_; + + public: + /** + \rst + Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the + given size. + \endrst + */ + BasicArrayWriter(Char *array, std::size_t size) + : BasicWriter(buffer_), buffer_(array, size) {} + + // FIXME: this is temporary undocumented due to a bug in Sphinx + /* + \rst + Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the + size known at compile time. + \endrst + */ + template + explicit BasicArrayWriter(Char (&array)[SIZE]) + : BasicWriter(buffer_), buffer_(array, SIZE) {} +}; + +typedef BasicArrayWriter ArrayWriter; +typedef BasicArrayWriter WArrayWriter; + // Formats a value. template -void format(BasicFormatter &f, const Char *&format_str, const T &value) -{ - std::basic_ostringstream os; - os << value; - internal::Arg arg; - internal::Value &arg_value = arg; - std::basic_string str = os.str(); - arg_value = internal::MakeValue(str); - arg.type = static_cast( - internal::MakeValue::type(str)); - format_str = f.format(format_str, arg); +void format(BasicFormatter &f, const Char *&format_str, const T &value) { + std::basic_ostringstream os; + os << value; + std::basic_string str = os.str(); + internal::Arg arg = internal::MakeValue(str); + arg.type = static_cast( + internal::MakeValue::type(str)); + format_str = f.format(format_str, arg); } // Reports a system error without throwing an exception. @@ -2587,45 +2353,43 @@ void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT; #ifdef _WIN32 /** A Windows error. */ -class WindowsError : public SystemError -{ -private: - void init(int error_code, StringRef format_str, ArgList args); +class WindowsError : public SystemError { + private: + void init(int error_code, StringRef format_str, ArgList args); -public: - /** - \rst - Constructs a :class:`fmt::WindowsError` object with the description - of the form + public: + /** + \rst + Constructs a :class:`fmt::WindowsError` object with the description + of the form - .. parsed-literal:: - **: ** + .. parsed-literal:: + **: ** - where ** is the formatted message and ** is the - system message corresponding to the error code. - *error_code* is a Windows error code as given by ``GetLastError``. - If *error_code* is not a valid error code such as -1, the system message - will look like "error -1". + where ** is the formatted message and ** is the + system message corresponding to the error code. + *error_code* is a Windows error code as given by ``GetLastError``. + If *error_code* is not a valid error code such as -1, the system message + will look like "error -1". - **Example**:: + **Example**:: - // This throws a WindowsError with the description - // cannot open file 'madeup': The system cannot find the file specified. - // or similar (system message may vary). - const char *filename = "madeup"; - LPOFSTRUCT of = LPOFSTRUCT(); - HFILE file = OpenFile(filename, &of, OF_READ); - if (file == HFILE_ERROR) { - throw fmt::WindowsError(GetLastError(), - "cannot open file '{}'", filename); - } - \endrst - */ - WindowsError(int error_code, StringRef message) - { - init(error_code, message, ArgList()); - } - FMT_VARIADIC_CTOR(WindowsError, init, int, StringRef) + // This throws a WindowsError with the description + // cannot open file 'madeup': The system cannot find the file specified. + // or similar (system message may vary). + const char *filename = "madeup"; + LPOFSTRUCT of = LPOFSTRUCT(); + HFILE file = OpenFile(filename, &of, OF_READ); + if (file == HFILE_ERROR) { + throw fmt::WindowsError(GetLastError(), + "cannot open file '{}'", filename); + } + \endrst + */ + WindowsError(int error_code, StringRef message) { + init(error_code, message, ArgList()); + } + FMT_VARIADIC_CTOR(WindowsError, init, int, StringRef) }; // Reports a Windows error without throwing an exception. @@ -2637,244 +2401,211 @@ void report_windows_error(int error_code, StringRef message) FMT_NOEXCEPT; enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE }; /** -Formats a string and prints it to stdout using ANSI escape sequences -to specify color (experimental). -Example: -PrintColored(fmt::RED, "Elapsed time: {0:.2f} seconds") << 1.23; -*/ + Formats a string and prints it to stdout using ANSI escape sequences + to specify color (experimental). + Example: + PrintColored(fmt::RED, "Elapsed time: {0:.2f} seconds") << 1.23; + */ void print_colored(Color c, StringRef format, ArgList args); /** -\rst -Formats arguments and returns the result as a string. + \rst + Formats arguments and returns the result as a string. -**Example**:: + **Example**:: -std::string message = format("The answer is {}", 42); -\endrst + std::string message = format("The answer is {}", 42); + \endrst */ -inline std::string format(StringRef format_str, ArgList args) -{ - MemoryWriter w; - w.write(format_str, args); - return w.str(); +inline std::string format(StringRef format_str, ArgList args) { + MemoryWriter w; + w.write(format_str, args); + return w.str(); } -inline std::wstring format(WStringRef format_str, ArgList args) -{ - WMemoryWriter w; - w.write(format_str, args); - return w.str(); +inline std::wstring format(WStringRef format_str, ArgList args) { + WMemoryWriter w; + w.write(format_str, args); + return w.str(); } /** -\rst -Prints formatted data to the file *f*. + \rst + Prints formatted data to the file *f*. -**Example**:: + **Example**:: -print(stderr, "Don't {}!", "panic"); -\endrst -*/ + print(stderr, "Don't {}!", "panic"); + \endrst + */ void print(std::FILE *f, StringRef format_str, ArgList args); /** -\rst -Prints formatted data to ``stdout``. + \rst + Prints formatted data to ``stdout``. -**Example**:: + **Example**:: -print("Elapsed time: {0:.2f} seconds", 1.23); -\endrst -*/ + print("Elapsed time: {0:.2f} seconds", 1.23); + \endrst + */ void print(StringRef format_str, ArgList args); /** -\rst -Prints formatted data to the stream *os*. + \rst + Prints formatted data to the stream *os*. -**Example**:: + **Example**:: -print(cerr, "Don't {}!", "panic"); -\endrst -*/ + print(cerr, "Don't {}!", "panic"); + \endrst + */ void print(std::ostream &os, StringRef format_str, ArgList args); template -void printf(BasicWriter &w, BasicStringRef format, ArgList args) -{ - internal::PrintfFormatter().format(w, format, args); +void printf(BasicWriter &w, BasicStringRef format, ArgList args) { + internal::PrintfFormatter().format(w, format, args); } /** -\rst -Formats arguments and returns the result as a string. + \rst + Formats arguments and returns the result as a string. -**Example**:: + **Example**:: -std::string message = fmt::sprintf("The answer is %d", 42); -\endrst + std::string message = fmt::sprintf("The answer is %d", 42); + \endrst */ -inline std::string sprintf(StringRef format, ArgList args) -{ - MemoryWriter w; - printf(w, format, args); - return w.str(); +inline std::string sprintf(StringRef format, ArgList args) { + MemoryWriter w; + printf(w, format, args); + return w.str(); } /** -\rst -Prints formatted data to the file *f*. + \rst + Prints formatted data to the file *f*. -**Example**:: + **Example**:: -fmt::fprintf(stderr, "Don't %s!", "panic"); -\endrst -*/ + fmt::fprintf(stderr, "Don't %s!", "panic"); + \endrst + */ int fprintf(std::FILE *f, StringRef format, ArgList args); /** -\rst -Prints formatted data to ``stdout``. + \rst + Prints formatted data to ``stdout``. -**Example**:: + **Example**:: -fmt::printf("Elapsed time: %.2f seconds", 1.23); -\endrst -*/ -inline int printf(StringRef format, ArgList args) -{ - return fprintf(stdout, format, args); + fmt::printf("Elapsed time: %.2f seconds", 1.23); + \endrst + */ +inline int printf(StringRef format, ArgList args) { + return fprintf(stdout, format, args); } /** -Fast integer formatter. -*/ -class FormatInt -{ -private: - // Buffer should be large enough to hold all digits (digits10 + 1), - // a sign and a null character. - enum { BUFFER_SIZE = std::numeric_limits::digits10 + 3 }; - mutable char buffer_[BUFFER_SIZE]; - char *str_; + Fast integer formatter. + */ +class FormatInt { + private: + // Buffer should be large enough to hold all digits (digits10 + 1), + // a sign and a null character. + enum {BUFFER_SIZE = std::numeric_limits::digits10 + 3}; + mutable char buffer_[BUFFER_SIZE]; + char *str_; - // Formats value in reverse and returns the number of digits. - char *format_decimal(ULongLong value) - { - char *buffer_end = buffer_ + BUFFER_SIZE - 1; - while (value >= 100) - { - // Integer division is slow so do it for a group of two digits instead - // of for every digit. The idea comes from the talk by Alexandrescu - // "Three Optimization Tips for C++". See speed-test for a comparison. - unsigned index = (value % 100) * 2; - value /= 100; - *--buffer_end = internal::Data::DIGITS[index + 1]; - *--buffer_end = internal::Data::DIGITS[index]; - } - if (value < 10) - { - *--buffer_end = static_cast('0' + value); - return buffer_end; - } - unsigned index = static_cast(value * 2); - *--buffer_end = internal::Data::DIGITS[index + 1]; - *--buffer_end = internal::Data::DIGITS[index]; - return buffer_end; + // Formats value in reverse and returns the number of digits. + char *format_decimal(ULongLong value) { + char *buffer_end = buffer_ + BUFFER_SIZE - 1; + while (value >= 100) { + // Integer division is slow so do it for a group of two digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + unsigned index = (value % 100) * 2; + value /= 100; + *--buffer_end = internal::Data::DIGITS[index + 1]; + *--buffer_end = internal::Data::DIGITS[index]; } + if (value < 10) { + *--buffer_end = static_cast('0' + value); + return buffer_end; + } + unsigned index = static_cast(value * 2); + *--buffer_end = internal::Data::DIGITS[index + 1]; + *--buffer_end = internal::Data::DIGITS[index]; + return buffer_end; + } - void FormatSigned(LongLong value) - { - ULongLong abs_value = static_cast(value); - bool negative = value < 0; - if (negative) - abs_value = 0 - abs_value; - str_ = format_decimal(abs_value); - if (negative) - *--str_ = '-'; - } + void FormatSigned(LongLong value) { + ULongLong abs_value = static_cast(value); + bool negative = value < 0; + if (negative) + abs_value = 0 - abs_value; + str_ = format_decimal(abs_value); + if (negative) + *--str_ = '-'; + } -public: - explicit FormatInt(int value) - { - FormatSigned(value); - } - explicit FormatInt(long value) - { - FormatSigned(value); - } - explicit FormatInt(LongLong value) - { - FormatSigned(value); - } - explicit FormatInt(unsigned value) : str_(format_decimal(value)) {} - explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {} - explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {} + public: + explicit FormatInt(int value) { FormatSigned(value); } + explicit FormatInt(long value) { FormatSigned(value); } + explicit FormatInt(LongLong value) { FormatSigned(value); } + explicit FormatInt(unsigned value) : str_(format_decimal(value)) {} + explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {} + explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {} - /** + /** Returns the number of characters written to the output buffer. - */ - std::size_t size() const - { - return buffer_ - str_ + BUFFER_SIZE - 1; - } + */ + std::size_t size() const { return buffer_ - str_ + BUFFER_SIZE - 1; } - /** + /** Returns a pointer to the output buffer content. No terminating null character is appended. - */ - const char *data() const - { - return str_; - } + */ + const char *data() const { return str_; } - /** + /** Returns a pointer to the output buffer content with terminating null character appended. - */ - const char *c_str() const - { - buffer_[BUFFER_SIZE - 1] = '\0'; - return str_; - } + */ + const char *c_str() const { + buffer_[BUFFER_SIZE - 1] = '\0'; + return str_; + } - /** + /** Returns the content of the output buffer as an `std::string`. - */ - std::string str() const - { - return std::string(str_, size()); - } + */ + std::string str() const { return std::string(str_, size()); } }; // Formats a decimal integer value writing into buffer and returns // a pointer to the end of the formatted string. This function doesn't // write a terminating null character. template -inline void format_decimal(char *&buffer, T value) -{ - typename internal::IntTraits::MainType abs_value = value; - if (internal::is_negative(value)) - { - *buffer++ = '-'; - abs_value = 0 - abs_value; +inline void format_decimal(char *&buffer, T value) { + typename internal::IntTraits::MainType abs_value = value; + if (internal::is_negative(value)) { + *buffer++ = '-'; + abs_value = 0 - abs_value; + } + if (abs_value < 100) { + if (abs_value < 10) { + *buffer++ = static_cast('0' + abs_value); + return; } - if (abs_value < 100) - { - if (abs_value < 10) - { - *buffer++ = static_cast('0' + abs_value); - return; - } - unsigned index = static_cast(abs_value * 2); - *buffer++ = internal::Data::DIGITS[index]; - *buffer++ = internal::Data::DIGITS[index + 1]; - return; - } - unsigned num_digits = internal::count_digits(abs_value); - internal::format_decimal(buffer, abs_value, num_digits); - buffer += num_digits; + unsigned index = static_cast(abs_value * 2); + *buffer++ = internal::Data::DIGITS[index]; + *buffer++ = internal::Data::DIGITS[index + 1]; + return; + } + unsigned num_digits = internal::count_digits(abs_value); + internal::format_decimal(buffer, abs_value, num_digits); + buffer += num_digits; } } @@ -2906,16 +2637,52 @@ inline void format_decimal(char *&buffer, T value) #define FMT_GET_ARG_NAME(type, index) arg##index #if FMT_USE_VARIADIC_TEMPLATES + +namespace fmt { +namespace internal { +inline void do_set_types(Arg *) {} + +template +inline void do_set_types(Arg *args, const T &arg, const Args & ... tail) { + args->type = static_cast(MakeValue::type(arg)); + do_set_types(args + 1, tail...); +} + +template +inline void set_types(Arg *array, const Args & ... args) { + do_set_types(array, args...); + array[sizeof...(Args)].type = Arg::NONE; +} + +template +inline void set_types(Value *, const Args & ...) { + // Do nothing as types are passed separately from values. +} + +// Computes the argument array size by adding 1 to N, which is the number of +// arguments, if N is zero, because array of zero size is invalid, or if N +// is greater than ArgList::MAX_PACKED_ARGS to accommodate for an extra +// argument that marks the end of the list. +template +struct ArgArraySize { + enum { VALUE = N + (N == 0 || N > ArgList::MAX_PACKED_ARGS ? 1 : 0) }; +}; +} +} + # define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \ template \ ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \ const Args & ... args) { \ - using fmt::internal::Value; \ - const Value values[fmt::internal::NonZero::VALUE] = { \ - fmt::internal::MakeValue(args)... \ + namespace internal = fmt::internal; \ + typedef typename internal::SelectValueType::Type Value; \ + Value array[internal::ArgArraySize::VALUE] = { \ + internal::MakeValue(args)... \ }; \ - call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \ - fmt::internal::make_type(args...), values)); \ + if (internal::check((sizeof...(Args) > fmt::ArgList::MAX_PACKED_ARGS))) \ + set_types(array, args...); \ + call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \ + fmt::ArgList(internal::make_type(args...), array)); \ } #else // Defines a wrapper for a function taking __VA_ARGS__ arguments @@ -2924,9 +2691,9 @@ inline void format_decimal(char *&buffer, T value) template \ inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \ FMT_GEN(n, FMT_MAKE_ARG)) { \ - const fmt::internal::Value vals[] = {FMT_GEN(n, FMT_MAKE_REF_##Char)}; \ + const fmt::internal::Value values[] = {FMT_GEN(n, FMT_MAKE_REF_##Char)}; \ call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \ - fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), vals)); \ + fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), values)); \ } # define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \ @@ -2951,40 +2718,39 @@ inline void format_decimal(char *&buffer, T value) #endif // FMT_USE_VARIADIC_TEMPLATES /** -\rst -Defines a variadic function with the specified return type, function name -and argument types passed as variable arguments to this macro. + \rst + Defines a variadic function with the specified return type, function name + and argument types passed as variable arguments to this macro. -**Example**:: + **Example**:: -void print_error(const char *file, int line, const char *format, -fmt::ArgList args) { -fmt::print("{}: {}: ", file, line); -fmt::print(format, args); -} -FMT_VARIADIC(void, print_error, const char *, int, const char *) + void print_error(const char *file, int line, const char *format, + fmt::ArgList args) { + fmt::print("{}: {}: ", file, line); + fmt::print(format, args); + } + FMT_VARIADIC(void, print_error, const char *, int, const char *) -``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that -don't implement variadic templates. You don't have to use this macro if -you don't need legacy compiler support and can use variadic templates -directly:: + ``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that + don't implement variadic templates. You don't have to use this macro if + you don't need legacy compiler support and can use variadic templates + directly:: -template -void print_error(const char *file, int line, const char *format, -const Args & ... args) { -fmt::print("{}: {}: ", file, line); -fmt::print(format, args...); -} -\endrst -*/ + template + void print_error(const char *file, int line, const char *format, + const Args & ... args) { + fmt::print("{}: {}: ", file, line); + fmt::print(format, args...); + } + \endrst + */ #define FMT_VARIADIC(ReturnType, func, ...) \ FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__) #define FMT_VARIADIC_W(ReturnType, func, ...) \ FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__) -namespace fmt -{ +namespace fmt { FMT_VARIADIC(std::string, format, StringRef) FMT_VARIADIC_W(std::wstring, format, WStringRef) FMT_VARIADIC(void, print, StringRef) @@ -3004,6 +2770,7 @@ FMT_VARIADIC(int, fprintf, std::FILE *, StringRef) #ifdef __clang__ # pragma clang diagnostic pop #endif + #ifdef FMT_HEADER_ONLY # include "format.cc" #endif From 80fcd655649eca5fec85c70b7016c6a63baa5100 Mon Sep 17 00:00:00 2001 From: gabime Date: Sun, 26 Apr 2015 23:47:26 +0300 Subject: [PATCH 58/60] bugfix while fixing bug #81 --- include/spdlog/details/format.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h index fd390caa..0e63d8e9 100644 --- a/include/spdlog/details/format.h +++ b/include/spdlog/details/format.h @@ -28,7 +28,7 @@ #ifndef FMT_FORMAT_H_ #define FMT_FORMAT_H_ -#ifdef FMT_HEADER_ONLY +#define FMT_HEADER_ONLY #include @@ -2775,4 +2775,4 @@ FMT_VARIADIC(int, fprintf, std::FILE *, StringRef) # include "format.cc" #endif -#endif // FMT_FORMAT_H_ \ No newline at end of file +#endif // FMT_FORMAT_H_ From da8024854e6ca7b9fd2fdd254e0d00558279fc7d Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 28 Apr 2015 01:13:33 +0300 Subject: [PATCH 59/60] Fixe bug #84 (mingw gives '_SH_DENYWR' was not declared in this scope') --- include/spdlog/details/os.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 18e3fb71..5745d421 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -32,6 +32,9 @@ # define WIN32_LEAN_AND_MEAN # endif # include +#ifdef __MINGW32__ +#include +#endif #elif __linux__ #include //Use gettid() syscall under linux to get thread id #include From 285a47dedb633d63b9e91468be209bab66527159 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 28 Apr 2015 01:23:15 +0300 Subject: [PATCH 60/60] Fix bug #84 --- include/spdlog/details/os.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 5745d421..753b6d91 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -32,9 +32,11 @@ # define WIN32_LEAN_AND_MEAN # endif # include + #ifdef __MINGW32__ #include #endif + #elif __linux__ #include //Use gettid() syscall under linux to get thread id #include