diff --git a/README.md b/README.md index 8d3e16f6..7db15533 100644 --- a/README.md +++ b/README.md @@ -5,18 +5,16 @@ Very fast, header only, C++ logging library. ## Install 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 -* visual studio 2013 -* mingw with g++ 4.9.x - +## Platforms + * Linux (gcc 4.8.1+, clang 3.5+) + * Windows (visual studio 2013+, mingw with g++ 4.9.1+) + * Mac OSX (clang 3.5+) + ##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. +* 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. @@ -73,7 +71,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,6 +96,11 @@ 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 // @@ -148,5 +151,8 @@ void custom_class_example() spdlog::get("console")->info("custom class with operator<<: {}..", c); spdlog::get("console")->info() << "custom class with operator<<: " << c << ".."; } - ``` + +## Documentation +Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages. + 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 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) { diff --git a/example/example.cpp b/example/example.cpp index af76966e..6159770a 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 - auto console = spd::stdout_logger_mt("console"); - console->info("Hello {}", 1); + //Create console, multithreaded logger + auto console = spd::stdout_logger_mt("console"); + 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!"; - + spdlog::drop_all(); //Close all loggers + // // 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,16 +110,17 @@ 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() { 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 << ".."; } diff --git a/include/spdlog/common.h b/include/spdlog/common.h index 23c91947..cde5a9eb 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -33,16 +33,9 @@ #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. -// 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 namespace spdlog { @@ -60,6 +53,7 @@ using sink_ptr = std::shared_ptr < sinks::sink > ; using sinks_init_list = std::initializer_list < sink_ptr > ; using formatter_ptr = std::shared_ptr; + //Log level enum namespace level { diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h index 8c04711f..657c70bb 100644 --- a/include/spdlog/details/async_log_helper.h +++ b/include/spdlog/details/async_log_helper.h @@ -59,44 +59,50 @@ class async_log_helper std::string logger_name; level::level_enum level; log_clock::time_point time; + size_t thread_id; std::string txt; async_msg() = default; ~async_msg() = default; - async_msg(const async_msg&) = delete; - async_msg& operator=(async_msg& other) = delete; - - async_msg(const details::log_msg& m) : - logger_name(m.logger_name), - level(m.level), - time(m.time), - txt(m.raw.data(), m.raw.size()) +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) : - 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) + async_msg& operator=(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; } + // 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), + time(m.time), + thread_id(m.thread_id), + txt(m.raw.data(), m.raw.size()) + {} + // copy into log_msg void fill_log_msg(log_msg &msg) { msg.clear(); msg.logger_name = logger_name; msg.level = level; msg.time = time; + msg.thread_id = thread_id; msg.raw << txt; } }; @@ -117,8 +123,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); @@ -147,11 +154,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); }; @@ -220,8 +227,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) { @@ -253,7 +260,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; @@ -261,7 +268,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; @@ -277,7 +284,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/format.cc b/include/spdlog/details/format.cc index 5ca49bbc..4de135cf 100644 --- a/include/spdlog/details/format.cc +++ b/include/spdlog/details/format.cc @@ -1,34 +1,31 @@ /* + Formatting library for C++ -Modified version of cppformat formatting library + Copyright (c) 2012 - 2015, Victor Zverovich + All rights reserved. -Orginal license: + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: -Copyright (c) 2012 - 2014, 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: - -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. -*/ + 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. + */ +#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 @@ -88,45 +80,64 @@ 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 +// 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)(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,209 +148,236 @@ 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) { - assert(buffer != 0 && buffer_size != 0); - int result = 0; -#ifdef _GNU_SOURCE - 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 safe_strerror( + 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(); } -FMT_FUNC void format_error_code(spdlog::details::fmt::Writer &out, int error_code, - spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { - // 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. - 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) - out << message << SEP; - out << FMT_ERROR << error_code; - assert(out.size() <= spdlog::details::fmt::internal::INLINE_BUFFER_SIZE); +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 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); } -FMT_FUNC void report_error(FormatFunc func, - int error_code, spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { - spdlog::details::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); +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); } // IsZeroInt::visit(arg) returns true iff arg is a zero integer. -class IsZeroInt : public spdlog::details::fmt::internal::ArgVisitor { -public: - template - bool visit_any_int(T value) { - return value == 0; - } +class IsZeroInt : public fmt::internal::ArgVisitor { + 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 -FMT_FUNC 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(spdlog::details::fmt::FormatError("number is too big")); - return value; +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; } 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)); - } + if (arg.type > Arg::LAST_NUMERIC_TYPE) { + std::string 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) { - 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))); - } - ++s; +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; } // 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 { -private: - spdlog::details::fmt::FormatSpec &spec_; +class WidthHandler : public fmt::internal::ArgVisitor { + private: + fmt::FormatSpec &spec_; -public: - explicit WidthHandler(spdlog::details::fmt::FormatSpec &spec) : spec_(spec) {} + FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler); - unsigned visit_unhandled_arg() { - FMT_THROW(spdlog::details::fmt::FormatError("width is not integer")); - return 0; - } - - template - unsigned visit_any_int(T value) { - typedef typename spdlog::details::fmt::internal::IntTraits::MainType UnsignedType; - UnsignedType width = value; - if (spdlog::details::fmt::internal::is_negative(value)) { - spec_.align_ = spdlog::details::fmt::ALIGN_LEFT; - width = 0 - width; - } - if (width > INT_MAX) - FMT_THROW(spdlog::details::fmt::FormatError("number is too big")); - return static_cast(width); + public: + explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {} + + 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 spdlog::details::fmt::internal::ArgVisitor { -public: - unsigned visit_unhandled_arg() { - FMT_THROW(spdlog::details::fmt::FormatError("precision is not integer")); - return 0; - } + public fmt::internal::ArgVisitor { + 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(spdlog::details::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 spdlog::details::fmt::internal::ArgVisitor, void> { -private: - spdlog::details::fmt::internal::Arg &arg_; - wchar_t type_; +class ArgConverter : public fmt::internal::ArgVisitor, void> { + private: + fmt::internal::Arg &arg_; + wchar_t type_; -public: - ArgConverter(spdlog::details::fmt::internal::Arg &arg, wchar_t type) - : arg_(arg), type_(type) {} + FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter); - template - void visit_any_int(U value) { - bool is_signed = type_ == 'd' || type_ == 'i'; - using spdlog::details::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); - } - } + 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); + } } + } }; // Converts an integer argument to char for printf. -class CharConverter : public spdlog::details::fmt::internal::ArgVisitor { -private: - spdlog::details::fmt::internal::Arg &arg_; +class CharConverter : public fmt::internal::ArgVisitor { + private: + fmt::internal::Arg &arg_; -public: - explicit CharConverter(spdlog::details::fmt::internal::Arg &arg) : arg_(arg) {} + FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter); - template - void visit_any_int(T value) { - arg_.type = Arg::CHAR; - arg_.int_value = static_cast(value); - } + 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); + } }; // This function template is used to prevent compile errors when handling @@ -350,56 +388,52 @@ 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 spdlog::details::fmt::SystemError::init( - int error_code, StringRef format_str, ArgList args) { - error_code_ = error_code; - MemoryWriter w; - internal::format_system_error(w, error_code, format(format_str, args)); - std::runtime_error &base = *this; - base = std::runtime_error(w.str()); +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()); } 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) { - 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 -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) { - 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 -const char spdlog::details::fmt::internal::BasicData::DIGITS[] = +const char fmt::internal::BasicData::DIGITS[] = "0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" @@ -418,753 +452,756 @@ const char spdlog::details::fmt::internal::BasicData::DIGITS[] = factor * 1000000000 template -const uint32_t spdlog::details::fmt::internal::BasicData::POWERS_OF_10_32[] = { - 0, FMT_POWERS_OF_10(1) +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[] = { - 0, - FMT_POWERS_OF_10(1), - FMT_POWERS_OF_10(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 +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 }; -FMT_FUNC void spdlog::details::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(spdlog::details::fmt::FormatError( - spdlog::details::fmt::format("unknown format code '\\x{:02x}' for {}", - static_cast(code), type))); +FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type) { + (void)type; + if (std::isprint(static_cast(code))) { + FMT_THROW(fmt::FormatError( + 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 spdlog::details::fmt::internal::UTF8ToUTF16::UTF8ToUTF16(spdlog::details::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"; - if (length == 0) - FMT_THROW(WindowsError(GetLastError(), FMT_ERROR)); - 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_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)); } -FMT_FUNC spdlog::details::fmt::internal::UTF16ToUTF8::UTF16ToUTF8(spdlog::details::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 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) { - 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 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; } -FMT_FUNC void spdlog::details::fmt::WindowsError::init( - int error_code, StringRef format_str, ArgList args) { - error_code_ = error_code; - MemoryWriter w; - internal::format_windows_error(w, error_code, format(format_str, args)); - std::runtime_error &base = *this; - base = std::runtime_error(w.str()); +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()); } #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 { - 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_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); } #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) { - class String { - private: - LPWSTR str_; +FMT_FUNC void fmt::internal::format_windows_error( + fmt::Writer &out, int error_code, + 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 // An argument formatter. template -class spdlog::details::fmt::internal::ArgFormatter : - public spdlog::details::fmt::internal::ArgVisitor, void> { -private: - spdlog::details::fmt::BasicFormatter &formatter_; - spdlog::details::fmt::BasicWriter &writer_; - spdlog::details::fmt::FormatSpec &spec_; - const Char *format_; +class fmt::internal::ArgFormatter : + public fmt::internal::ArgVisitor, void> { + private: + fmt::BasicFormatter &formatter_; + fmt::BasicWriter &writer_; + fmt::FormatSpec &spec_; + const Char *format_; -public: - ArgFormatter( - spdlog::details::fmt::BasicFormatter &f, spdlog::details::fmt::FormatSpec &s, const Char *fmt) - : formatter_(f), writer_(f.writer()), spec_(s), format_(fmt) {} + FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatter); - template - void visit_any_int(T value) { - writer_.write_int(value, spec_); - } + public: + ArgFormatter( + fmt::BasicFormatter &f,fmt::FormatSpec &s, const Char *fmt) + : formatter_(f), writer_(f.writer()), spec_(s), format_(fmt) {} - template - void visit_any_double(T value) { - writer_.write_double(value, spec_); - } + template + void visit_any_int(T value) { writer_.write_int(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 spdlog::details::fmt::BasicWriter::CharPtr CharPtr; - 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) { - std::fill_n(out, spec_.width_ - 1, fill); - out += spec_.width_ - 1; - } - else if (spec_.align_ == spdlog::details::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_char(int value) { + if (spec_.type_ && spec_.type_ != 'c') { + spec_.flags_ |= CHAR_FLAG; + writer_.write_int(value, spec_); + return; } - void visit_wstring(Arg::StringValue value) { - writer_.write_str(ignore_incompatible_str(value), spec_); + 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') - spdlog::details::fmt::internal::report_unknown_type(spec_.type_, "pointer"); - spec_.flags_ = spdlog::details::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_custom(Arg::CustomValue c) { - c.format(&formatter_, c.value, &format_); - } + 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_); + } }; +template +void fmt::internal::FixedBuffer::grow(std::size_t) { + FMT_THROW(std::runtime_error("buffer overflow")); +} + template template -FMT_FUNC void spdlog::details::fmt::BasicWriter::write_str( - const Arg::StringValue &str, 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) - FMT_THROW(FormatError("string pointer is null")); - if (*s) - size = std::char_traits::length(s); - } - write_str(s, size, 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 *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 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); - if (error) { - FMT_THROW(FormatError( - *s != '}' && *s != ':' ? "invalid format string" : error)); - } - return arg; +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; } -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) - 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 spdlog::details::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 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; - 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 -FMT_FUNC void spdlog::details::fmt::internal::PrintfFormatter::parse_flags( +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 -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 ? - 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 -FMT_FUNC unsigned spdlog::details::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; - } - } +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; + } } - 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 -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(); - 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 *s = "s"; - arg.custom.format(&writer, arg.custom.value, &s); - 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); -template -FMT_FUNC const Char *spdlog::details::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; - } + 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; - // 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; - break; - case '-': - check_sign(s, arg); - spec.flags_ |= MINUS_FLAG; - break; - case ' ': - check_sign(s, arg); - spec.flags_ |= SIGN_FLAG; - break; - } - - 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::DOUBLE && arg.type != Arg::LONG_DOUBLE) { - FMT_THROW(FormatError( - "precision specifier requires floating-point argument")); - } - } - - // Parse type. - if (*s != '}' && *s) - spec.type_ = static_cast(*s++); + spec.precision_ = PrecisionHandler().visit(get_arg(s)); + } } - if (*s++ != '}') - FMT_THROW(FormatError("missing '}' in format string")); - start_ = 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. - internal::ArgFormatter(*this, spec, s - 1).visit(arg); - return s; + 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 -FMT_FUNC void spdlog::details::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 *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; } - write(writer_, start_, 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; + break; + case '-': + check_sign(s, arg); + spec.flags_ |= MINUS_FLAG; + break; + case ' ': + check_sign(s, arg); + spec.flags_ |= SIGN_FLAG; + break; + } + + 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; } -FMT_FUNC void spdlog::details::fmt::report_system_error( - int error_code, spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { - report_error(internal::format_system_error, error_code, message); +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); + } + 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); } #ifdef _WIN32 -FMT_FUNC void spdlog::details::fmt::report_windows_error( - int error_code, spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) { - report_error(internal::format_windows_error, error_code, message); +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) { - MemoryWriter w; - w.write(format_str, args); - std::fwrite(w.data(), 1, w.size(), f); +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) { - print(stdout, format_str, 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) { - MemoryWriter w; - w.write(format_str, args); - os.write(w.data(), w.size()); +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) { - char escape[] = "\x1b[30m"; - escape[3] = '0' + static_cast(c); - std::fputs(escape, stdout); - print(format, args); - std::fputs(RESET_COLOR, stdout); +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); } -FMT_FUNC int spdlog::details::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); +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); } +#ifndef FMT_HEADER_ONLY + // Explicit instantiations for char. -template const char *spdlog::details::fmt::BasicFormatter::format( - const char *&format_str, const spdlog::details::fmt::internal::Arg &arg); +template void fmt::internal::FixedBuffer::grow(std::size_t); -template void spdlog::details::fmt::BasicFormatter::format( - BasicStringRef format, const ArgList &args); +template const char *fmt::BasicFormatter::format( + const char *&format_str, const fmt::internal::Arg &arg); -template void spdlog::details::fmt::internal::PrintfFormatter::format( - BasicWriter &writer, BasicStringRef format, const ArgList &args); +template void fmt::BasicFormatter::format( + BasicStringRef format, const ArgList &args); -template int spdlog::details::fmt::internal::CharTraits::format_float( +template void fmt::internal::PrintfFormatter::format( + BasicWriter &writer, BasicStringRef format, const ArgList &args); + +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 void fmt::internal::FixedBuffer::grow(std::size_t); -template void spdlog::details::fmt::BasicFormatter::format( +template const wchar_t *fmt::BasicFormatter::format( + const wchar_t *&format_str, const fmt::internal::Arg &arg); + +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); +#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 3934f812..0e63d8e9 100644 --- a/include/spdlog/details/format.h +++ b/include/spdlog/details/format.h @@ -1,32 +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 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,66 @@ 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 push +# pragma clang diagnostic ignored "-Wdocumentation" +#endif + #ifdef __GNUC_LIBSTD__ # define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__) #endif @@ -77,13 +122,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 +145,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 +155,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. @@ -144,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, 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 }; @@ -251,260 +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(true) - { - 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 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 -struct IsLongDouble -{ - enum { VALUE = 0 }; -}; - -template <> -struct IsLongDouble -{ - enum { VALUE = 1 }; -}; - 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 }; @@ -512,103 +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: - typedef const wchar_t *UnsupportedStrType; + 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: - typedef const char *UnsupportedStrType; +class CharTraits : public BasicCharTraits { + public: + static wchar_t convert(char value) { return value; } + static wchar_t convert(wchar_t value) { return value; } - 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 <> \ @@ -626,340 +584,373 @@ 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; +#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) -{ - // 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; - 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; } -# 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) -{ - 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; } #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 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 +// 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 +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; }; -// Makes a Value object from any type. +template +struct WCharHelper { + typedef T Supported; + typedef None Unsupported; +}; + +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); - void set_string(StringRef str) - { - string.value = str.c_str(); - string.size = str.size(); - } + // 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(WStringRef str) - { - CharTraits::convert(wchar_t()); - wstring.value = str.c_str(); - wstring.size = str.size(); - } + void set_string(StringRef str) { + string.value = str.c_str(); + string.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)); - } + void set_string(WStringRef str) { + wstring.value = str.c_str(); + wstring.size = str.size(); + } -public: - MakeValue() {} + // 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() {} #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(wchar_t value) - { - int_value = internal::CharTraits::convert(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) - 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_VALUE(void *, pointer, POINTER) - FMT_MAKE_VALUE(const void *, pointer, POINTER) + 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) - template - MakeValue(const T &value) - { - custom.value = &value; - custom.format = &format_custom_arg; - } - template - static uint64_t type(const T &) - { - return Arg::CUSTOM; - } + FMT_MAKE_VALUE(void *, pointer, POINTER) + FMT_MAKE_VALUE(const void *, pointer, POINTER) + + 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 @@ -985,254 +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); - // Fall through. - 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, 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); - // 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. @@ -1240,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 value, const SpecT &spec = SpecT()) - : SpecT(spec), value_(value) {} + 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 = ' '); @@ -1425,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 */ \ @@ -1456,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) @@ -1479,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 @@ -1522,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 @@ -1575,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 @@ -1605,13 +1527,14 @@ 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) \ + 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) \ @@ -1621,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) \ @@ -1663,1088 +1586,1028 @@ 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 error_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 :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. - *error_code* is a system error code as given by ``errno``. - \endrst - */ - SystemError(int error_code, StringRef message) - { - init(error_code, message, ArgList()); - } - FMT_VARIADIC_CTOR(SystemError, init, int, StringRef) + public: + /** + \rst + Constructs a :class:`fmt::SystemError` object with the description + of the form - int error_code() const - { - return error_code_; - } + .. 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) { + init(error_code, message, ArgList()); + } + FMT_VARIADIC_CTOR(SystemError, init, int, StringRef) + + 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 :cpp: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 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*. - // Do not implement! - void operator<<(typename internal::CharTraits::UnsupportedStrType); + // 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); - friend class internal::ArgFormatter; - friend class internal::PrintfFormatter; + // 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'; + } -protected: - /** + template + void append_float_length(Char *&, T) {} + + friend class internal::ArgFormatter; + friend class internal::PrintfFormatter; + + 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(true) - { - 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 :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) - { - 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<<(wchar_t value) - { - buffer_.push_back(internal::CharTraits::convert(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(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) -{ - 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 size = 4; - const char *nan = upper ? " NAN" : " nan"; - if (!sign) - { - --size; - ++nan; - } - CharPtr out = write_str(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 size = 4; - const char *inf = upper ? " INF" : " inf"; - if (!sign) - { - --size; - ++inf; - } - CharPtr out = write_str(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; + 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; } - else - { - if (spec.align() == ALIGN_LEFT) - *format_ptr++ = '-'; - if (width != 0) - *format_ptr++ = '*'; - } - if (spec.precision() >= 0) - { - *format_ptr++ = '.'; - *format_ptr++ = '*'; - } - if (internal::IsLongDouble::VALUE) - *format_ptr++ = 'L'; - *format_ptr++ = type; - *format_ptr = '\0'; + CharPtr out = write_str(inf, inf_size, spec); + if (sign) + *out = sign; + return; + } - // Format using snprintf. - Char fill = static_cast(spec.fill()); - for (;;) - { - std::size_t size = buffer_.capacity() - offset; + 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; + } + + // 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 (size == 0) - { - buffer_.reserve(offset + 1); - 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) - { - 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)) - { - unsigned 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 - /** - Constructs a ``BasicMemoryWriter`` object moving the content of the other - object to it. - */ - BasicMemoryWriter(BasicMemoryWriter &&other) - : BasicWriter(buffer_), buffer_(std::move(other.buffer_)) - { - } + /** + \rst + Constructs a :class:`fmt::BasicMemoryWriter` object moving the content + of the other object to it. + \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 = internal::Arg::STRING; - 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. // 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 -{ -private: - void init(int error_code, StringRef format_str, ArgList args); +/** 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. - *error_code* is a Windows error code as given by ``GetLastError``. - \endrst - */ - WindowsError(int error_code, StringRef message) - { - init(error_code, message, ArgList()); - } - FMT_VARIADIC_CTOR(WindowsError, init, int, StringRef) + public: + /** + \rst + 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) { + init(error_code, message, ArgList()); + } + FMT_VARIADIC_CTOR(WindowsError, init, int, StringRef) }; // 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 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; +} } -} // ns fmt -} // ns deatils -} // ns spdlog #if FMT_GCC_VERSION // Use the system_header pragma to suppress warnings about variadic macros @@ -2774,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 @@ -2792,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, ...) \ @@ -2819,44 +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 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 +2761,18 @@ 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 -# include "format.cc" - -#ifdef __GNUC__ -# pragma GCC diagnostic pop //pop -Wshadow warnings ignore +#ifdef __clang__ +# pragma clang diagnostic pop #endif -#endif // SPDLOG_FMT_FORMAT_H_ +#ifdef FMT_HEADER_ONLY +# include "format.cc" +#endif + +#endif // FMT_FORMAT_H_ diff --git a/include/spdlog/details/line_logger.h b/include/spdlog/details/line_logger.h index fa616fcf..3a946cb6 100644 --- a/include/spdlog/details/line_logger.h +++ b/include/spdlog/details/line_logger.h @@ -27,7 +27,6 @@ #include "../common.h" #include "../logger.h" - // Line logger class - aggregates operator<< calls to fast ostream // and logs upon destruction @@ -63,8 +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/log_msg.h b/include/spdlog/details/log_msg.h index d9fb39b0..bf58aca9 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" @@ -37,7 +38,6 @@ struct log_msg log_msg(level::level_enum l): logger_name(), level(l), - time(), raw(), formatted() {} @@ -45,7 +45,8 @@ struct log_msg log_msg(const log_msg& other) : logger_name(other.logger_name), level(other.level), - time(other.time) + time(other.time), + thread_id(other.thread_id) { if (other.raw.size()) raw << fmt::BasicStringRef(other.raw.data(), other.raw.size()); @@ -57,6 +58,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 +73,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(); @@ -87,6 +90,7 @@ struct log_msg std::string logger_name; level::level_enum level; log_clock::time_point time; + size_t thread_id; fmt::MemoryWriter raw; fmt::MemoryWriter formatted; }; diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 67e64ecd..753b6d91 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -32,6 +32,16 @@ # define WIN32_LEAN_AND_MEAN # endif # include + +#ifdef __MINGW32__ +#include +#endif + +#elif __linux__ +#include //Use gettid() syscall under linux to get thread id +#include +#else +#include #endif #include "../common.h" @@ -46,7 +56,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( @@ -73,7 +83,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 +103,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) @@ -166,6 +176,19 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime()) #endif } +//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() +{ +#ifdef _WIN32 + return static_cast(::GetCurrentThreadId()); +#elif __linux__ + 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 + +} } //os } //details diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h index b904d32d..a5b2d21f 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 << msg.thread_id; } }; @@ -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()); } }; @@ -478,7 +489,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; @@ -490,7 +501,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; @@ -610,8 +621,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/details/registry.h b/include/spdlog/details/registry.h index 2d1c2339..5f708743 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -41,10 +41,17 @@ namespace spdlog { namespace details { - class registry { public: + + void register_logger(std::shared_ptr logger) + { + std::lock_guard lock(_mutex); + register_logger_impl(logger); + } + + std::shared_ptr get(const std::string& logger_name) { std::lock_guard lock(_mutex); @@ -55,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 @@ -68,8 +75,9 @@ public: if (_formatter) new_logger->set_formatter(_formatter); + new_logger->set_level(_level); - _loggers[logger_name] = new_logger; + register_logger_impl(new_logger); return new_logger; } @@ -103,14 +111,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 +124,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 +142,6 @@ public: _async_mode = false; } - static registry& instance() { static registry s_instance; @@ -143,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 69fb85d8..5e1bc73a 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) +{ + return details::registry::instance().register_logger(logger); +} + inline std::shared_ptr spdlog::get(const std::string& name) { return details::registry::instance().get(name); @@ -54,35 +59,35 @@ 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); } // 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/file_sinks.h b/include/spdlog/sinks/file_sinks.h index 0f73f5c5..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,11 +92,10 @@ protected: _file_helper.write(msg); } - 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 @@ -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,60 +146,70 @@ 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: - 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)); } - 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 static std::string calc_filename(const std::string& basename, const std::string& extension) { 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); + 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(); } 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/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; diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index 497a6f49..8601555f 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -28,16 +28,12 @@ #pragma once - - +#include "tweakme.h" #include "common.h" #include "logger.h" - - namespace spdlog { - // Return an existing logger or nullptr if a logger with such name doesn't exist. // Examples: // @@ -55,7 +51,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 +65,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); @@ -78,20 +74,20 @@ 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); // -// 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); // -// 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); @@ -100,50 +96,27 @@ 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&...); -// -// 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. -// -// Example: -// -// Enable debug macro, must be defined before including 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->force_log(spdlog::level::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__) -#else -#define SPDLOG_DEBUG(logger, ...) -#endif - +// Register the given logger with the given name +void register_logger(std::shared_ptr logger); // Drop the reference to the given logger void drop(const std::string &name); @@ -151,6 +124,31 @@ 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. +// Uncomment SPDLOG_DEBUG_ON/SPDLOG_TRACE_ON in teakme.h to enable. +// +// Example: +// 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 +#define SPDLOG_TRACE(logger, ...) +#endif + +#ifdef SPDLOG_DEBUG_ON +#define SPDLOG_DEBUG(logger, ...) logger->debug(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")"; +#else +#define SPDLOG_DEBUG(logger, ...) +#endif + + } diff --git a/include/spdlog/tweakme.h b/include/spdlog/tweakme.h new file mode 100644 index 00000000..20e2c5e4 --- /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 of 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 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 +///////////////////////////////////////////////////////////////////////////////